1#![allow(clippy::useless_conversion)]
2use crate::hummock::*;
3impl serde::Serialize for BloomFilterType {
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 let variant = match self {
10 Self::BloomFilterUnspecified => "BLOOM_FILTER_UNSPECIFIED",
11 Self::Sstable => "SSTABLE",
12 Self::Blocked => "BLOCKED",
13 };
14 serializer.serialize_str(variant)
15 }
16}
17impl<'de> serde::Deserialize<'de> for BloomFilterType {
18 #[allow(deprecated)]
19 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20 where
21 D: serde::Deserializer<'de>,
22 {
23 const FIELDS: &[&str] = &[
24 "BLOOM_FILTER_UNSPECIFIED",
25 "SSTABLE",
26 "BLOCKED",
27 ];
28
29 struct GeneratedVisitor;
30
31 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
32 type Value = BloomFilterType;
33
34 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
35 write!(formatter, "expected one of: {:?}", &FIELDS)
36 }
37
38 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
39 where
40 E: serde::de::Error,
41 {
42 i32::try_from(v)
43 .ok()
44 .and_then(|x| x.try_into().ok())
45 .ok_or_else(|| {
46 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
47 })
48 }
49
50 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
51 where
52 E: serde::de::Error,
53 {
54 i32::try_from(v)
55 .ok()
56 .and_then(|x| x.try_into().ok())
57 .ok_or_else(|| {
58 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
59 })
60 }
61
62 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
63 where
64 E: serde::de::Error,
65 {
66 match value {
67 "BLOOM_FILTER_UNSPECIFIED" => Ok(BloomFilterType::BloomFilterUnspecified),
68 "SSTABLE" => Ok(BloomFilterType::Sstable),
69 "BLOCKED" => Ok(BloomFilterType::Blocked),
70 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
71 }
72 }
73 }
74 deserializer.deserialize_any(GeneratedVisitor)
75 }
76}
77impl serde::Serialize for BranchedObject {
78 #[allow(deprecated)]
79 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
80 where
81 S: serde::Serializer,
82 {
83 use serde::ser::SerializeStruct;
84 let mut len = 0;
85 if self.object_id != 0 {
86 len += 1;
87 }
88 if !self.sst_id.is_empty() {
89 len += 1;
90 }
91 if self.compaction_group_id != 0 {
92 len += 1;
93 }
94 let mut struct_ser = serializer.serialize_struct("hummock.BranchedObject", len)?;
95 if self.object_id != 0 {
96 #[allow(clippy::needless_borrow)]
97 #[allow(clippy::needless_borrows_for_generic_args)]
98 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
99 }
100 if !self.sst_id.is_empty() {
101 struct_ser.serialize_field("sstId", &self.sst_id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
102 }
103 if self.compaction_group_id != 0 {
104 #[allow(clippy::needless_borrow)]
105 #[allow(clippy::needless_borrows_for_generic_args)]
106 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
107 }
108 struct_ser.end()
109 }
110}
111impl<'de> serde::Deserialize<'de> for BranchedObject {
112 #[allow(deprecated)]
113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
114 where
115 D: serde::Deserializer<'de>,
116 {
117 const FIELDS: &[&str] = &[
118 "object_id",
119 "objectId",
120 "sst_id",
121 "sstId",
122 "compaction_group_id",
123 "compactionGroupId",
124 ];
125
126 #[allow(clippy::enum_variant_names)]
127 enum GeneratedField {
128 ObjectId,
129 SstId,
130 CompactionGroupId,
131 }
132 impl<'de> serde::Deserialize<'de> for GeneratedField {
133 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
134 where
135 D: serde::Deserializer<'de>,
136 {
137 struct GeneratedVisitor;
138
139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
140 type Value = GeneratedField;
141
142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
143 write!(formatter, "expected one of: {:?}", &FIELDS)
144 }
145
146 #[allow(unused_variables)]
147 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
148 where
149 E: serde::de::Error,
150 {
151 match value {
152 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
153 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
154 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
156 }
157 }
158 }
159 deserializer.deserialize_identifier(GeneratedVisitor)
160 }
161 }
162 struct GeneratedVisitor;
163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
164 type Value = BranchedObject;
165
166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
167 formatter.write_str("struct hummock.BranchedObject")
168 }
169
170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BranchedObject, V::Error>
171 where
172 V: serde::de::MapAccess<'de>,
173 {
174 let mut object_id__ = None;
175 let mut sst_id__ = None;
176 let mut compaction_group_id__ = None;
177 while let Some(k) = map_.next_key()? {
178 match k {
179 GeneratedField::ObjectId => {
180 if object_id__.is_some() {
181 return Err(serde::de::Error::duplicate_field("objectId"));
182 }
183 object_id__ =
184 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
185 ;
186 }
187 GeneratedField::SstId => {
188 if sst_id__.is_some() {
189 return Err(serde::de::Error::duplicate_field("sstId"));
190 }
191 sst_id__ =
192 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
193 .into_iter().map(|x| x.0).collect())
194 ;
195 }
196 GeneratedField::CompactionGroupId => {
197 if compaction_group_id__.is_some() {
198 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
199 }
200 compaction_group_id__ =
201 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
202 ;
203 }
204 }
205 }
206 Ok(BranchedObject {
207 object_id: object_id__.unwrap_or_default(),
208 sst_id: sst_id__.unwrap_or_default(),
209 compaction_group_id: compaction_group_id__.unwrap_or_default(),
210 })
211 }
212 }
213 deserializer.deserialize_struct("hummock.BranchedObject", FIELDS, GeneratedVisitor)
214 }
215}
216impl serde::Serialize for CancelCompactTask {
217 #[allow(deprecated)]
218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
219 where
220 S: serde::Serializer,
221 {
222 use serde::ser::SerializeStruct;
223 let mut len = 0;
224 if self.context_id != 0 {
225 len += 1;
226 }
227 if self.task_id != 0 {
228 len += 1;
229 }
230 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTask", len)?;
231 if self.context_id != 0 {
232 struct_ser.serialize_field("contextId", &self.context_id)?;
233 }
234 if self.task_id != 0 {
235 #[allow(clippy::needless_borrow)]
236 #[allow(clippy::needless_borrows_for_generic_args)]
237 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
238 }
239 struct_ser.end()
240 }
241}
242impl<'de> serde::Deserialize<'de> for CancelCompactTask {
243 #[allow(deprecated)]
244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
245 where
246 D: serde::Deserializer<'de>,
247 {
248 const FIELDS: &[&str] = &[
249 "context_id",
250 "contextId",
251 "task_id",
252 "taskId",
253 ];
254
255 #[allow(clippy::enum_variant_names)]
256 enum GeneratedField {
257 ContextId,
258 TaskId,
259 }
260 impl<'de> serde::Deserialize<'de> for GeneratedField {
261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
262 where
263 D: serde::Deserializer<'de>,
264 {
265 struct GeneratedVisitor;
266
267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
268 type Value = GeneratedField;
269
270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
271 write!(formatter, "expected one of: {:?}", &FIELDS)
272 }
273
274 #[allow(unused_variables)]
275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
276 where
277 E: serde::de::Error,
278 {
279 match value {
280 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
281 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
283 }
284 }
285 }
286 deserializer.deserialize_identifier(GeneratedVisitor)
287 }
288 }
289 struct GeneratedVisitor;
290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
291 type Value = CancelCompactTask;
292
293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
294 formatter.write_str("struct hummock.CancelCompactTask")
295 }
296
297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTask, V::Error>
298 where
299 V: serde::de::MapAccess<'de>,
300 {
301 let mut context_id__ = None;
302 let mut task_id__ = None;
303 while let Some(k) = map_.next_key()? {
304 match k {
305 GeneratedField::ContextId => {
306 if context_id__.is_some() {
307 return Err(serde::de::Error::duplicate_field("contextId"));
308 }
309 context_id__ =
310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
311 ;
312 }
313 GeneratedField::TaskId => {
314 if task_id__.is_some() {
315 return Err(serde::de::Error::duplicate_field("taskId"));
316 }
317 task_id__ =
318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
319 ;
320 }
321 }
322 }
323 Ok(CancelCompactTask {
324 context_id: context_id__.unwrap_or_default(),
325 task_id: task_id__.unwrap_or_default(),
326 })
327 }
328 }
329 deserializer.deserialize_struct("hummock.CancelCompactTask", FIELDS, GeneratedVisitor)
330 }
331}
332impl serde::Serialize for CancelCompactTaskRequest {
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 != 0 {
341 len += 1;
342 }
343 if self.task_status != 0 {
344 len += 1;
345 }
346 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskRequest", len)?;
347 if self.task_id != 0 {
348 #[allow(clippy::needless_borrow)]
349 #[allow(clippy::needless_borrows_for_generic_args)]
350 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
351 }
352 if self.task_status != 0 {
353 let v = compact_task::TaskStatus::try_from(self.task_status)
354 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
355 struct_ser.serialize_field("taskStatus", &v)?;
356 }
357 struct_ser.end()
358 }
359}
360impl<'de> serde::Deserialize<'de> for CancelCompactTaskRequest {
361 #[allow(deprecated)]
362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
363 where
364 D: serde::Deserializer<'de>,
365 {
366 const FIELDS: &[&str] = &[
367 "task_id",
368 "taskId",
369 "task_status",
370 "taskStatus",
371 ];
372
373 #[allow(clippy::enum_variant_names)]
374 enum GeneratedField {
375 TaskId,
376 TaskStatus,
377 }
378 impl<'de> serde::Deserialize<'de> for GeneratedField {
379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
380 where
381 D: serde::Deserializer<'de>,
382 {
383 struct GeneratedVisitor;
384
385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
386 type Value = GeneratedField;
387
388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
389 write!(formatter, "expected one of: {:?}", &FIELDS)
390 }
391
392 #[allow(unused_variables)]
393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
394 where
395 E: serde::de::Error,
396 {
397 match value {
398 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
399 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
400 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
401 }
402 }
403 }
404 deserializer.deserialize_identifier(GeneratedVisitor)
405 }
406 }
407 struct GeneratedVisitor;
408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
409 type Value = CancelCompactTaskRequest;
410
411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
412 formatter.write_str("struct hummock.CancelCompactTaskRequest")
413 }
414
415 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskRequest, V::Error>
416 where
417 V: serde::de::MapAccess<'de>,
418 {
419 let mut task_id__ = None;
420 let mut task_status__ = None;
421 while let Some(k) = map_.next_key()? {
422 match k {
423 GeneratedField::TaskId => {
424 if task_id__.is_some() {
425 return Err(serde::de::Error::duplicate_field("taskId"));
426 }
427 task_id__ =
428 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
429 ;
430 }
431 GeneratedField::TaskStatus => {
432 if task_status__.is_some() {
433 return Err(serde::de::Error::duplicate_field("taskStatus"));
434 }
435 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
436 }
437 }
438 }
439 Ok(CancelCompactTaskRequest {
440 task_id: task_id__.unwrap_or_default(),
441 task_status: task_status__.unwrap_or_default(),
442 })
443 }
444 }
445 deserializer.deserialize_struct("hummock.CancelCompactTaskRequest", FIELDS, GeneratedVisitor)
446 }
447}
448impl serde::Serialize for CancelCompactTaskResponse {
449 #[allow(deprecated)]
450 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
451 where
452 S: serde::Serializer,
453 {
454 use serde::ser::SerializeStruct;
455 let mut len = 0;
456 if self.ret {
457 len += 1;
458 }
459 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskResponse", len)?;
460 if self.ret {
461 struct_ser.serialize_field("ret", &self.ret)?;
462 }
463 struct_ser.end()
464 }
465}
466impl<'de> serde::Deserialize<'de> for CancelCompactTaskResponse {
467 #[allow(deprecated)]
468 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
469 where
470 D: serde::Deserializer<'de>,
471 {
472 const FIELDS: &[&str] = &[
473 "ret",
474 ];
475
476 #[allow(clippy::enum_variant_names)]
477 enum GeneratedField {
478 Ret,
479 }
480 impl<'de> serde::Deserialize<'de> for GeneratedField {
481 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
482 where
483 D: serde::Deserializer<'de>,
484 {
485 struct GeneratedVisitor;
486
487 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
488 type Value = GeneratedField;
489
490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
491 write!(formatter, "expected one of: {:?}", &FIELDS)
492 }
493
494 #[allow(unused_variables)]
495 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
496 where
497 E: serde::de::Error,
498 {
499 match value {
500 "ret" => Ok(GeneratedField::Ret),
501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
502 }
503 }
504 }
505 deserializer.deserialize_identifier(GeneratedVisitor)
506 }
507 }
508 struct GeneratedVisitor;
509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
510 type Value = CancelCompactTaskResponse;
511
512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
513 formatter.write_str("struct hummock.CancelCompactTaskResponse")
514 }
515
516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskResponse, V::Error>
517 where
518 V: serde::de::MapAccess<'de>,
519 {
520 let mut ret__ = None;
521 while let Some(k) = map_.next_key()? {
522 match k {
523 GeneratedField::Ret => {
524 if ret__.is_some() {
525 return Err(serde::de::Error::duplicate_field("ret"));
526 }
527 ret__ = Some(map_.next_value()?);
528 }
529 }
530 }
531 Ok(CancelCompactTaskResponse {
532 ret: ret__.unwrap_or_default(),
533 })
534 }
535 }
536 deserializer.deserialize_struct("hummock.CancelCompactTaskResponse", FIELDS, GeneratedVisitor)
537 }
538}
539impl serde::Serialize for CompactStatus {
540 #[allow(deprecated)]
541 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
542 where
543 S: serde::Serializer,
544 {
545 use serde::ser::SerializeStruct;
546 let mut len = 0;
547 if self.compaction_group_id != 0 {
548 len += 1;
549 }
550 if !self.level_handlers.is_empty() {
551 len += 1;
552 }
553 let mut struct_ser = serializer.serialize_struct("hummock.CompactStatus", len)?;
554 if self.compaction_group_id != 0 {
555 #[allow(clippy::needless_borrow)]
556 #[allow(clippy::needless_borrows_for_generic_args)]
557 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
558 }
559 if !self.level_handlers.is_empty() {
560 struct_ser.serialize_field("levelHandlers", &self.level_handlers)?;
561 }
562 struct_ser.end()
563 }
564}
565impl<'de> serde::Deserialize<'de> for CompactStatus {
566 #[allow(deprecated)]
567 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
568 where
569 D: serde::Deserializer<'de>,
570 {
571 const FIELDS: &[&str] = &[
572 "compaction_group_id",
573 "compactionGroupId",
574 "level_handlers",
575 "levelHandlers",
576 ];
577
578 #[allow(clippy::enum_variant_names)]
579 enum GeneratedField {
580 CompactionGroupId,
581 LevelHandlers,
582 }
583 impl<'de> serde::Deserialize<'de> for GeneratedField {
584 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
585 where
586 D: serde::Deserializer<'de>,
587 {
588 struct GeneratedVisitor;
589
590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
591 type Value = GeneratedField;
592
593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
594 write!(formatter, "expected one of: {:?}", &FIELDS)
595 }
596
597 #[allow(unused_variables)]
598 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
599 where
600 E: serde::de::Error,
601 {
602 match value {
603 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
604 "levelHandlers" | "level_handlers" => Ok(GeneratedField::LevelHandlers),
605 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
606 }
607 }
608 }
609 deserializer.deserialize_identifier(GeneratedVisitor)
610 }
611 }
612 struct GeneratedVisitor;
613 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
614 type Value = CompactStatus;
615
616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
617 formatter.write_str("struct hummock.CompactStatus")
618 }
619
620 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactStatus, V::Error>
621 where
622 V: serde::de::MapAccess<'de>,
623 {
624 let mut compaction_group_id__ = None;
625 let mut level_handlers__ = None;
626 while let Some(k) = map_.next_key()? {
627 match k {
628 GeneratedField::CompactionGroupId => {
629 if compaction_group_id__.is_some() {
630 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
631 }
632 compaction_group_id__ =
633 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
634 ;
635 }
636 GeneratedField::LevelHandlers => {
637 if level_handlers__.is_some() {
638 return Err(serde::de::Error::duplicate_field("levelHandlers"));
639 }
640 level_handlers__ = Some(map_.next_value()?);
641 }
642 }
643 }
644 Ok(CompactStatus {
645 compaction_group_id: compaction_group_id__.unwrap_or_default(),
646 level_handlers: level_handlers__.unwrap_or_default(),
647 })
648 }
649 }
650 deserializer.deserialize_struct("hummock.CompactStatus", FIELDS, GeneratedVisitor)
651 }
652}
653impl serde::Serialize for CompactTask {
654 #[allow(deprecated)]
655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
656 where
657 S: serde::Serializer,
658 {
659 use serde::ser::SerializeStruct;
660 let mut len = 0;
661 if !self.input_ssts.is_empty() {
662 len += 1;
663 }
664 if !self.splits.is_empty() {
665 len += 1;
666 }
667 if !self.sorted_output_ssts.is_empty() {
668 len += 1;
669 }
670 if self.task_id != 0 {
671 len += 1;
672 }
673 if self.target_level != 0 {
674 len += 1;
675 }
676 if self.gc_delete_keys {
677 len += 1;
678 }
679 if self.base_level != 0 {
680 len += 1;
681 }
682 if self.task_status != 0 {
683 len += 1;
684 }
685 if self.compaction_group_id != 0 {
686 len += 1;
687 }
688 if !self.existing_table_ids.is_empty() {
689 len += 1;
690 }
691 if self.compression_algorithm != 0 {
692 len += 1;
693 }
694 if self.target_file_size != 0 {
695 len += 1;
696 }
697 if self.compaction_filter_mask != 0 {
698 len += 1;
699 }
700 if !self.table_options.is_empty() {
701 len += 1;
702 }
703 if self.current_epoch_time != 0 {
704 len += 1;
705 }
706 if self.target_sub_level_id != 0 {
707 len += 1;
708 }
709 if self.task_type != 0 {
710 len += 1;
711 }
712 if self.split_by_state_table {
713 len += 1;
714 }
715 if self.split_weight_by_vnode != 0 {
716 len += 1;
717 }
718 if !self.table_vnode_partition.is_empty() {
719 len += 1;
720 }
721 if !self.table_watermarks.is_empty() {
722 len += 1;
723 }
724 if !self.table_schemas.is_empty() {
725 len += 1;
726 }
727 if self.max_sub_compaction != 0 {
728 len += 1;
729 }
730 if self.compaction_group_version_id != 0 {
731 len += 1;
732 }
733 if self.max_kv_count_for_xor16.is_some() {
734 len += 1;
735 }
736 let mut struct_ser = serializer.serialize_struct("hummock.CompactTask", len)?;
737 if !self.input_ssts.is_empty() {
738 struct_ser.serialize_field("inputSsts", &self.input_ssts)?;
739 }
740 if !self.splits.is_empty() {
741 struct_ser.serialize_field("splits", &self.splits)?;
742 }
743 if !self.sorted_output_ssts.is_empty() {
744 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
745 }
746 if self.task_id != 0 {
747 #[allow(clippy::needless_borrow)]
748 #[allow(clippy::needless_borrows_for_generic_args)]
749 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
750 }
751 if self.target_level != 0 {
752 struct_ser.serialize_field("targetLevel", &self.target_level)?;
753 }
754 if self.gc_delete_keys {
755 struct_ser.serialize_field("gcDeleteKeys", &self.gc_delete_keys)?;
756 }
757 if self.base_level != 0 {
758 struct_ser.serialize_field("baseLevel", &self.base_level)?;
759 }
760 if self.task_status != 0 {
761 let v = compact_task::TaskStatus::try_from(self.task_status)
762 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
763 struct_ser.serialize_field("taskStatus", &v)?;
764 }
765 if self.compaction_group_id != 0 {
766 #[allow(clippy::needless_borrow)]
767 #[allow(clippy::needless_borrows_for_generic_args)]
768 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
769 }
770 if !self.existing_table_ids.is_empty() {
771 struct_ser.serialize_field("existingTableIds", &self.existing_table_ids)?;
772 }
773 if self.compression_algorithm != 0 {
774 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
775 }
776 if self.target_file_size != 0 {
777 #[allow(clippy::needless_borrow)]
778 #[allow(clippy::needless_borrows_for_generic_args)]
779 struct_ser.serialize_field("targetFileSize", ToString::to_string(&self.target_file_size).as_str())?;
780 }
781 if self.compaction_filter_mask != 0 {
782 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
783 }
784 if !self.table_options.is_empty() {
785 struct_ser.serialize_field("tableOptions", &self.table_options)?;
786 }
787 if self.current_epoch_time != 0 {
788 #[allow(clippy::needless_borrow)]
789 #[allow(clippy::needless_borrows_for_generic_args)]
790 struct_ser.serialize_field("currentEpochTime", ToString::to_string(&self.current_epoch_time).as_str())?;
791 }
792 if self.target_sub_level_id != 0 {
793 #[allow(clippy::needless_borrow)]
794 #[allow(clippy::needless_borrows_for_generic_args)]
795 struct_ser.serialize_field("targetSubLevelId", ToString::to_string(&self.target_sub_level_id).as_str())?;
796 }
797 if self.task_type != 0 {
798 let v = compact_task::TaskType::try_from(self.task_type)
799 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_type)))?;
800 struct_ser.serialize_field("taskType", &v)?;
801 }
802 if self.split_by_state_table {
803 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
804 }
805 if self.split_weight_by_vnode != 0 {
806 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
807 }
808 if !self.table_vnode_partition.is_empty() {
809 struct_ser.serialize_field("tableVnodePartition", &self.table_vnode_partition)?;
810 }
811 if !self.table_watermarks.is_empty() {
812 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
813 }
814 if !self.table_schemas.is_empty() {
815 struct_ser.serialize_field("tableSchemas", &self.table_schemas)?;
816 }
817 if self.max_sub_compaction != 0 {
818 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
819 }
820 if self.compaction_group_version_id != 0 {
821 #[allow(clippy::needless_borrow)]
822 #[allow(clippy::needless_borrows_for_generic_args)]
823 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
824 }
825 if let Some(v) = self.max_kv_count_for_xor16.as_ref() {
826 #[allow(clippy::needless_borrow)]
827 #[allow(clippy::needless_borrows_for_generic_args)]
828 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
829 }
830 struct_ser.end()
831 }
832}
833impl<'de> serde::Deserialize<'de> for CompactTask {
834 #[allow(deprecated)]
835 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
836 where
837 D: serde::Deserializer<'de>,
838 {
839 const FIELDS: &[&str] = &[
840 "input_ssts",
841 "inputSsts",
842 "splits",
843 "sorted_output_ssts",
844 "sortedOutputSsts",
845 "task_id",
846 "taskId",
847 "target_level",
848 "targetLevel",
849 "gc_delete_keys",
850 "gcDeleteKeys",
851 "base_level",
852 "baseLevel",
853 "task_status",
854 "taskStatus",
855 "compaction_group_id",
856 "compactionGroupId",
857 "existing_table_ids",
858 "existingTableIds",
859 "compression_algorithm",
860 "compressionAlgorithm",
861 "target_file_size",
862 "targetFileSize",
863 "compaction_filter_mask",
864 "compactionFilterMask",
865 "table_options",
866 "tableOptions",
867 "current_epoch_time",
868 "currentEpochTime",
869 "target_sub_level_id",
870 "targetSubLevelId",
871 "task_type",
872 "taskType",
873 "split_by_state_table",
874 "splitByStateTable",
875 "split_weight_by_vnode",
876 "splitWeightByVnode",
877 "table_vnode_partition",
878 "tableVnodePartition",
879 "table_watermarks",
880 "tableWatermarks",
881 "table_schemas",
882 "tableSchemas",
883 "max_sub_compaction",
884 "maxSubCompaction",
885 "compaction_group_version_id",
886 "compactionGroupVersionId",
887 "max_kv_count_for_xor16",
888 "maxKvCountForXor16",
889 ];
890
891 #[allow(clippy::enum_variant_names)]
892 enum GeneratedField {
893 InputSsts,
894 Splits,
895 SortedOutputSsts,
896 TaskId,
897 TargetLevel,
898 GcDeleteKeys,
899 BaseLevel,
900 TaskStatus,
901 CompactionGroupId,
902 ExistingTableIds,
903 CompressionAlgorithm,
904 TargetFileSize,
905 CompactionFilterMask,
906 TableOptions,
907 CurrentEpochTime,
908 TargetSubLevelId,
909 TaskType,
910 SplitByStateTable,
911 SplitWeightByVnode,
912 TableVnodePartition,
913 TableWatermarks,
914 TableSchemas,
915 MaxSubCompaction,
916 CompactionGroupVersionId,
917 MaxKvCountForXor16,
918 }
919 impl<'de> serde::Deserialize<'de> for GeneratedField {
920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
921 where
922 D: serde::Deserializer<'de>,
923 {
924 struct GeneratedVisitor;
925
926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
927 type Value = GeneratedField;
928
929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
930 write!(formatter, "expected one of: {:?}", &FIELDS)
931 }
932
933 #[allow(unused_variables)]
934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
935 where
936 E: serde::de::Error,
937 {
938 match value {
939 "inputSsts" | "input_ssts" => Ok(GeneratedField::InputSsts),
940 "splits" => Ok(GeneratedField::Splits),
941 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
942 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
943 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
944 "gcDeleteKeys" | "gc_delete_keys" => Ok(GeneratedField::GcDeleteKeys),
945 "baseLevel" | "base_level" => Ok(GeneratedField::BaseLevel),
946 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
947 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
948 "existingTableIds" | "existing_table_ids" => Ok(GeneratedField::ExistingTableIds),
949 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
950 "targetFileSize" | "target_file_size" => Ok(GeneratedField::TargetFileSize),
951 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
952 "tableOptions" | "table_options" => Ok(GeneratedField::TableOptions),
953 "currentEpochTime" | "current_epoch_time" => Ok(GeneratedField::CurrentEpochTime),
954 "targetSubLevelId" | "target_sub_level_id" => Ok(GeneratedField::TargetSubLevelId),
955 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
956 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
957 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
958 "tableVnodePartition" | "table_vnode_partition" => Ok(GeneratedField::TableVnodePartition),
959 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
960 "tableSchemas" | "table_schemas" => Ok(GeneratedField::TableSchemas),
961 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
962 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
963 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
965 }
966 }
967 }
968 deserializer.deserialize_identifier(GeneratedVisitor)
969 }
970 }
971 struct GeneratedVisitor;
972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
973 type Value = CompactTask;
974
975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
976 formatter.write_str("struct hummock.CompactTask")
977 }
978
979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTask, V::Error>
980 where
981 V: serde::de::MapAccess<'de>,
982 {
983 let mut input_ssts__ = None;
984 let mut splits__ = None;
985 let mut sorted_output_ssts__ = None;
986 let mut task_id__ = None;
987 let mut target_level__ = None;
988 let mut gc_delete_keys__ = None;
989 let mut base_level__ = None;
990 let mut task_status__ = None;
991 let mut compaction_group_id__ = None;
992 let mut existing_table_ids__ = None;
993 let mut compression_algorithm__ = None;
994 let mut target_file_size__ = None;
995 let mut compaction_filter_mask__ = None;
996 let mut table_options__ = None;
997 let mut current_epoch_time__ = None;
998 let mut target_sub_level_id__ = None;
999 let mut task_type__ = None;
1000 let mut split_by_state_table__ = None;
1001 let mut split_weight_by_vnode__ = None;
1002 let mut table_vnode_partition__ = None;
1003 let mut table_watermarks__ = None;
1004 let mut table_schemas__ = None;
1005 let mut max_sub_compaction__ = None;
1006 let mut compaction_group_version_id__ = None;
1007 let mut max_kv_count_for_xor16__ = None;
1008 while let Some(k) = map_.next_key()? {
1009 match k {
1010 GeneratedField::InputSsts => {
1011 if input_ssts__.is_some() {
1012 return Err(serde::de::Error::duplicate_field("inputSsts"));
1013 }
1014 input_ssts__ = Some(map_.next_value()?);
1015 }
1016 GeneratedField::Splits => {
1017 if splits__.is_some() {
1018 return Err(serde::de::Error::duplicate_field("splits"));
1019 }
1020 splits__ = Some(map_.next_value()?);
1021 }
1022 GeneratedField::SortedOutputSsts => {
1023 if sorted_output_ssts__.is_some() {
1024 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
1025 }
1026 sorted_output_ssts__ = Some(map_.next_value()?);
1027 }
1028 GeneratedField::TaskId => {
1029 if task_id__.is_some() {
1030 return Err(serde::de::Error::duplicate_field("taskId"));
1031 }
1032 task_id__ =
1033 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1034 ;
1035 }
1036 GeneratedField::TargetLevel => {
1037 if target_level__.is_some() {
1038 return Err(serde::de::Error::duplicate_field("targetLevel"));
1039 }
1040 target_level__ =
1041 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1042 ;
1043 }
1044 GeneratedField::GcDeleteKeys => {
1045 if gc_delete_keys__.is_some() {
1046 return Err(serde::de::Error::duplicate_field("gcDeleteKeys"));
1047 }
1048 gc_delete_keys__ = Some(map_.next_value()?);
1049 }
1050 GeneratedField::BaseLevel => {
1051 if base_level__.is_some() {
1052 return Err(serde::de::Error::duplicate_field("baseLevel"));
1053 }
1054 base_level__ =
1055 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1056 ;
1057 }
1058 GeneratedField::TaskStatus => {
1059 if task_status__.is_some() {
1060 return Err(serde::de::Error::duplicate_field("taskStatus"));
1061 }
1062 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
1063 }
1064 GeneratedField::CompactionGroupId => {
1065 if compaction_group_id__.is_some() {
1066 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1067 }
1068 compaction_group_id__ =
1069 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1070 ;
1071 }
1072 GeneratedField::ExistingTableIds => {
1073 if existing_table_ids__.is_some() {
1074 return Err(serde::de::Error::duplicate_field("existingTableIds"));
1075 }
1076 existing_table_ids__ =
1077 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1078 .into_iter().map(|x| x.0).collect())
1079 ;
1080 }
1081 GeneratedField::CompressionAlgorithm => {
1082 if compression_algorithm__.is_some() {
1083 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
1084 }
1085 compression_algorithm__ =
1086 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1087 ;
1088 }
1089 GeneratedField::TargetFileSize => {
1090 if target_file_size__.is_some() {
1091 return Err(serde::de::Error::duplicate_field("targetFileSize"));
1092 }
1093 target_file_size__ =
1094 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1095 ;
1096 }
1097 GeneratedField::CompactionFilterMask => {
1098 if compaction_filter_mask__.is_some() {
1099 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
1100 }
1101 compaction_filter_mask__ =
1102 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1103 ;
1104 }
1105 GeneratedField::TableOptions => {
1106 if table_options__.is_some() {
1107 return Err(serde::de::Error::duplicate_field("tableOptions"));
1108 }
1109 table_options__ = Some(
1110 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1111 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1112 );
1113 }
1114 GeneratedField::CurrentEpochTime => {
1115 if current_epoch_time__.is_some() {
1116 return Err(serde::de::Error::duplicate_field("currentEpochTime"));
1117 }
1118 current_epoch_time__ =
1119 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1120 ;
1121 }
1122 GeneratedField::TargetSubLevelId => {
1123 if target_sub_level_id__.is_some() {
1124 return Err(serde::de::Error::duplicate_field("targetSubLevelId"));
1125 }
1126 target_sub_level_id__ =
1127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1128 ;
1129 }
1130 GeneratedField::TaskType => {
1131 if task_type__.is_some() {
1132 return Err(serde::de::Error::duplicate_field("taskType"));
1133 }
1134 task_type__ = Some(map_.next_value::<compact_task::TaskType>()? as i32);
1135 }
1136 GeneratedField::SplitByStateTable => {
1137 if split_by_state_table__.is_some() {
1138 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
1139 }
1140 split_by_state_table__ = Some(map_.next_value()?);
1141 }
1142 GeneratedField::SplitWeightByVnode => {
1143 if split_weight_by_vnode__.is_some() {
1144 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
1145 }
1146 split_weight_by_vnode__ =
1147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1148 ;
1149 }
1150 GeneratedField::TableVnodePartition => {
1151 if table_vnode_partition__.is_some() {
1152 return Err(serde::de::Error::duplicate_field("tableVnodePartition"));
1153 }
1154 table_vnode_partition__ = Some(
1155 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
1156 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
1157 );
1158 }
1159 GeneratedField::TableWatermarks => {
1160 if table_watermarks__.is_some() {
1161 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
1162 }
1163 table_watermarks__ = Some(
1164 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1165 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1166 );
1167 }
1168 GeneratedField::TableSchemas => {
1169 if table_schemas__.is_some() {
1170 return Err(serde::de::Error::duplicate_field("tableSchemas"));
1171 }
1172 table_schemas__ = Some(
1173 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1174 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1175 );
1176 }
1177 GeneratedField::MaxSubCompaction => {
1178 if max_sub_compaction__.is_some() {
1179 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
1180 }
1181 max_sub_compaction__ =
1182 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1183 ;
1184 }
1185 GeneratedField::CompactionGroupVersionId => {
1186 if compaction_group_version_id__.is_some() {
1187 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
1188 }
1189 compaction_group_version_id__ =
1190 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1191 ;
1192 }
1193 GeneratedField::MaxKvCountForXor16 => {
1194 if max_kv_count_for_xor16__.is_some() {
1195 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
1196 }
1197 max_kv_count_for_xor16__ =
1198 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1199 ;
1200 }
1201 }
1202 }
1203 Ok(CompactTask {
1204 input_ssts: input_ssts__.unwrap_or_default(),
1205 splits: splits__.unwrap_or_default(),
1206 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
1207 task_id: task_id__.unwrap_or_default(),
1208 target_level: target_level__.unwrap_or_default(),
1209 gc_delete_keys: gc_delete_keys__.unwrap_or_default(),
1210 base_level: base_level__.unwrap_or_default(),
1211 task_status: task_status__.unwrap_or_default(),
1212 compaction_group_id: compaction_group_id__.unwrap_or_default(),
1213 existing_table_ids: existing_table_ids__.unwrap_or_default(),
1214 compression_algorithm: compression_algorithm__.unwrap_or_default(),
1215 target_file_size: target_file_size__.unwrap_or_default(),
1216 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
1217 table_options: table_options__.unwrap_or_default(),
1218 current_epoch_time: current_epoch_time__.unwrap_or_default(),
1219 target_sub_level_id: target_sub_level_id__.unwrap_or_default(),
1220 task_type: task_type__.unwrap_or_default(),
1221 split_by_state_table: split_by_state_table__.unwrap_or_default(),
1222 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
1223 table_vnode_partition: table_vnode_partition__.unwrap_or_default(),
1224 table_watermarks: table_watermarks__.unwrap_or_default(),
1225 table_schemas: table_schemas__.unwrap_or_default(),
1226 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
1227 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
1228 max_kv_count_for_xor16: max_kv_count_for_xor16__,
1229 })
1230 }
1231 }
1232 deserializer.deserialize_struct("hummock.CompactTask", FIELDS, GeneratedVisitor)
1233 }
1234}
1235impl serde::Serialize for compact_task::TaskStatus {
1236 #[allow(deprecated)]
1237 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1238 where
1239 S: serde::Serializer,
1240 {
1241 let variant = match self {
1242 Self::Unspecified => "UNSPECIFIED",
1243 Self::Pending => "PENDING",
1244 Self::Success => "SUCCESS",
1245 Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
1246 Self::NoAvailMemoryResourceCanceled => "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1247 Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
1248 Self::SendFailCanceled => "SEND_FAIL_CANCELED",
1249 Self::ManualCanceled => "MANUAL_CANCELED",
1250 Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
1251 Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
1252 Self::ExecuteFailed => "EXECUTE_FAILED",
1253 Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
1254 Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
1255 Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
1256 Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
1257 Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
1258 Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
1259 Self::ServerlessTableNotFoundCanceled => "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1260 };
1261 serializer.serialize_str(variant)
1262 }
1263}
1264impl<'de> serde::Deserialize<'de> for compact_task::TaskStatus {
1265 #[allow(deprecated)]
1266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1267 where
1268 D: serde::Deserializer<'de>,
1269 {
1270 const FIELDS: &[&str] = &[
1271 "UNSPECIFIED",
1272 "PENDING",
1273 "SUCCESS",
1274 "HEARTBEAT_CANCELED",
1275 "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1276 "ASSIGN_FAIL_CANCELED",
1277 "SEND_FAIL_CANCELED",
1278 "MANUAL_CANCELED",
1279 "INVALID_GROUP_CANCELED",
1280 "INPUT_OUTDATED_CANCELED",
1281 "EXECUTE_FAILED",
1282 "JOIN_HANDLE_FAILED",
1283 "TRACK_SST_OBJECT_ID_FAILED",
1284 "NO_AVAIL_CPU_RESOURCE_CANCELED",
1285 "HEARTBEAT_PROGRESS_CANCELED",
1286 "RETENTION_TIME_REJECTED",
1287 "SERVERLESS_SEND_FAIL_CANCELED",
1288 "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1289 ];
1290
1291 struct GeneratedVisitor;
1292
1293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1294 type Value = compact_task::TaskStatus;
1295
1296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1297 write!(formatter, "expected one of: {:?}", &FIELDS)
1298 }
1299
1300 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1301 where
1302 E: serde::de::Error,
1303 {
1304 i32::try_from(v)
1305 .ok()
1306 .and_then(|x| x.try_into().ok())
1307 .ok_or_else(|| {
1308 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1309 })
1310 }
1311
1312 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1313 where
1314 E: serde::de::Error,
1315 {
1316 i32::try_from(v)
1317 .ok()
1318 .and_then(|x| x.try_into().ok())
1319 .ok_or_else(|| {
1320 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1321 })
1322 }
1323
1324 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1325 where
1326 E: serde::de::Error,
1327 {
1328 match value {
1329 "UNSPECIFIED" => Ok(compact_task::TaskStatus::Unspecified),
1330 "PENDING" => Ok(compact_task::TaskStatus::Pending),
1331 "SUCCESS" => Ok(compact_task::TaskStatus::Success),
1332 "HEARTBEAT_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatCanceled),
1333 "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailMemoryResourceCanceled),
1334 "ASSIGN_FAIL_CANCELED" => Ok(compact_task::TaskStatus::AssignFailCanceled),
1335 "SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::SendFailCanceled),
1336 "MANUAL_CANCELED" => Ok(compact_task::TaskStatus::ManualCanceled),
1337 "INVALID_GROUP_CANCELED" => Ok(compact_task::TaskStatus::InvalidGroupCanceled),
1338 "INPUT_OUTDATED_CANCELED" => Ok(compact_task::TaskStatus::InputOutdatedCanceled),
1339 "EXECUTE_FAILED" => Ok(compact_task::TaskStatus::ExecuteFailed),
1340 "JOIN_HANDLE_FAILED" => Ok(compact_task::TaskStatus::JoinHandleFailed),
1341 "TRACK_SST_OBJECT_ID_FAILED" => Ok(compact_task::TaskStatus::TrackSstObjectIdFailed),
1342 "NO_AVAIL_CPU_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailCpuResourceCanceled),
1343 "HEARTBEAT_PROGRESS_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatProgressCanceled),
1344 "RETENTION_TIME_REJECTED" => Ok(compact_task::TaskStatus::RetentionTimeRejected),
1345 "SERVERLESS_SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::ServerlessSendFailCanceled),
1346 "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => Ok(compact_task::TaskStatus::ServerlessTableNotFoundCanceled),
1347 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1348 }
1349 }
1350 }
1351 deserializer.deserialize_any(GeneratedVisitor)
1352 }
1353}
1354impl serde::Serialize for compact_task::TaskType {
1355 #[allow(deprecated)]
1356 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1357 where
1358 S: serde::Serializer,
1359 {
1360 let variant = match self {
1361 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1362 Self::Dynamic => "DYNAMIC",
1363 Self::SpaceReclaim => "SPACE_RECLAIM",
1364 Self::Manual => "MANUAL",
1365 Self::SharedBuffer => "SHARED_BUFFER",
1366 Self::Ttl => "TTL",
1367 Self::Tombstone => "TOMBSTONE",
1368 Self::Emergency => "EMERGENCY",
1369 Self::VnodeWatermark => "VNODE_WATERMARK",
1370 };
1371 serializer.serialize_str(variant)
1372 }
1373}
1374impl<'de> serde::Deserialize<'de> for compact_task::TaskType {
1375 #[allow(deprecated)]
1376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1377 where
1378 D: serde::Deserializer<'de>,
1379 {
1380 const FIELDS: &[&str] = &[
1381 "TYPE_UNSPECIFIED",
1382 "DYNAMIC",
1383 "SPACE_RECLAIM",
1384 "MANUAL",
1385 "SHARED_BUFFER",
1386 "TTL",
1387 "TOMBSTONE",
1388 "EMERGENCY",
1389 "VNODE_WATERMARK",
1390 ];
1391
1392 struct GeneratedVisitor;
1393
1394 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1395 type Value = compact_task::TaskType;
1396
1397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1398 write!(formatter, "expected one of: {:?}", &FIELDS)
1399 }
1400
1401 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1402 where
1403 E: serde::de::Error,
1404 {
1405 i32::try_from(v)
1406 .ok()
1407 .and_then(|x| x.try_into().ok())
1408 .ok_or_else(|| {
1409 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1410 })
1411 }
1412
1413 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1414 where
1415 E: serde::de::Error,
1416 {
1417 i32::try_from(v)
1418 .ok()
1419 .and_then(|x| x.try_into().ok())
1420 .ok_or_else(|| {
1421 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1422 })
1423 }
1424
1425 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1426 where
1427 E: serde::de::Error,
1428 {
1429 match value {
1430 "TYPE_UNSPECIFIED" => Ok(compact_task::TaskType::TypeUnspecified),
1431 "DYNAMIC" => Ok(compact_task::TaskType::Dynamic),
1432 "SPACE_RECLAIM" => Ok(compact_task::TaskType::SpaceReclaim),
1433 "MANUAL" => Ok(compact_task::TaskType::Manual),
1434 "SHARED_BUFFER" => Ok(compact_task::TaskType::SharedBuffer),
1435 "TTL" => Ok(compact_task::TaskType::Ttl),
1436 "TOMBSTONE" => Ok(compact_task::TaskType::Tombstone),
1437 "EMERGENCY" => Ok(compact_task::TaskType::Emergency),
1438 "VNODE_WATERMARK" => Ok(compact_task::TaskType::VnodeWatermark),
1439 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1440 }
1441 }
1442 }
1443 deserializer.deserialize_any(GeneratedVisitor)
1444 }
1445}
1446impl serde::Serialize for CompactTaskAssignment {
1447 #[allow(deprecated)]
1448 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1449 where
1450 S: serde::Serializer,
1451 {
1452 use serde::ser::SerializeStruct;
1453 let mut len = 0;
1454 if self.compact_task.is_some() {
1455 len += 1;
1456 }
1457 if self.context_id != 0 {
1458 len += 1;
1459 }
1460 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskAssignment", len)?;
1461 if let Some(v) = self.compact_task.as_ref() {
1462 struct_ser.serialize_field("compactTask", v)?;
1463 }
1464 if self.context_id != 0 {
1465 struct_ser.serialize_field("contextId", &self.context_id)?;
1466 }
1467 struct_ser.end()
1468 }
1469}
1470impl<'de> serde::Deserialize<'de> for CompactTaskAssignment {
1471 #[allow(deprecated)]
1472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1473 where
1474 D: serde::Deserializer<'de>,
1475 {
1476 const FIELDS: &[&str] = &[
1477 "compact_task",
1478 "compactTask",
1479 "context_id",
1480 "contextId",
1481 ];
1482
1483 #[allow(clippy::enum_variant_names)]
1484 enum GeneratedField {
1485 CompactTask,
1486 ContextId,
1487 }
1488 impl<'de> serde::Deserialize<'de> for GeneratedField {
1489 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1490 where
1491 D: serde::Deserializer<'de>,
1492 {
1493 struct GeneratedVisitor;
1494
1495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1496 type Value = GeneratedField;
1497
1498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1499 write!(formatter, "expected one of: {:?}", &FIELDS)
1500 }
1501
1502 #[allow(unused_variables)]
1503 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1504 where
1505 E: serde::de::Error,
1506 {
1507 match value {
1508 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
1509 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
1510 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1511 }
1512 }
1513 }
1514 deserializer.deserialize_identifier(GeneratedVisitor)
1515 }
1516 }
1517 struct GeneratedVisitor;
1518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1519 type Value = CompactTaskAssignment;
1520
1521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1522 formatter.write_str("struct hummock.CompactTaskAssignment")
1523 }
1524
1525 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskAssignment, V::Error>
1526 where
1527 V: serde::de::MapAccess<'de>,
1528 {
1529 let mut compact_task__ = None;
1530 let mut context_id__ = None;
1531 while let Some(k) = map_.next_key()? {
1532 match k {
1533 GeneratedField::CompactTask => {
1534 if compact_task__.is_some() {
1535 return Err(serde::de::Error::duplicate_field("compactTask"));
1536 }
1537 compact_task__ = map_.next_value()?;
1538 }
1539 GeneratedField::ContextId => {
1540 if context_id__.is_some() {
1541 return Err(serde::de::Error::duplicate_field("contextId"));
1542 }
1543 context_id__ =
1544 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1545 ;
1546 }
1547 }
1548 }
1549 Ok(CompactTaskAssignment {
1550 compact_task: compact_task__,
1551 context_id: context_id__.unwrap_or_default(),
1552 })
1553 }
1554 }
1555 deserializer.deserialize_struct("hummock.CompactTaskAssignment", FIELDS, GeneratedVisitor)
1556 }
1557}
1558impl serde::Serialize for CompactTaskProgress {
1559 #[allow(deprecated)]
1560 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1561 where
1562 S: serde::Serializer,
1563 {
1564 use serde::ser::SerializeStruct;
1565 let mut len = 0;
1566 if self.task_id != 0 {
1567 len += 1;
1568 }
1569 if self.num_ssts_sealed != 0 {
1570 len += 1;
1571 }
1572 if self.num_ssts_uploaded != 0 {
1573 len += 1;
1574 }
1575 if self.num_progress_key != 0 {
1576 len += 1;
1577 }
1578 if self.num_pending_read_io != 0 {
1579 len += 1;
1580 }
1581 if self.num_pending_write_io != 0 {
1582 len += 1;
1583 }
1584 if self.compaction_group_id.is_some() {
1585 len += 1;
1586 }
1587 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskProgress", len)?;
1588 if self.task_id != 0 {
1589 #[allow(clippy::needless_borrow)]
1590 #[allow(clippy::needless_borrows_for_generic_args)]
1591 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
1592 }
1593 if self.num_ssts_sealed != 0 {
1594 struct_ser.serialize_field("numSstsSealed", &self.num_ssts_sealed)?;
1595 }
1596 if self.num_ssts_uploaded != 0 {
1597 struct_ser.serialize_field("numSstsUploaded", &self.num_ssts_uploaded)?;
1598 }
1599 if self.num_progress_key != 0 {
1600 #[allow(clippy::needless_borrow)]
1601 #[allow(clippy::needless_borrows_for_generic_args)]
1602 struct_ser.serialize_field("numProgressKey", ToString::to_string(&self.num_progress_key).as_str())?;
1603 }
1604 if self.num_pending_read_io != 0 {
1605 #[allow(clippy::needless_borrow)]
1606 #[allow(clippy::needless_borrows_for_generic_args)]
1607 struct_ser.serialize_field("numPendingReadIo", ToString::to_string(&self.num_pending_read_io).as_str())?;
1608 }
1609 if self.num_pending_write_io != 0 {
1610 #[allow(clippy::needless_borrow)]
1611 #[allow(clippy::needless_borrows_for_generic_args)]
1612 struct_ser.serialize_field("numPendingWriteIo", ToString::to_string(&self.num_pending_write_io).as_str())?;
1613 }
1614 if let Some(v) = self.compaction_group_id.as_ref() {
1615 #[allow(clippy::needless_borrow)]
1616 #[allow(clippy::needless_borrows_for_generic_args)]
1617 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&v).as_str())?;
1618 }
1619 struct_ser.end()
1620 }
1621}
1622impl<'de> serde::Deserialize<'de> for CompactTaskProgress {
1623 #[allow(deprecated)]
1624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1625 where
1626 D: serde::Deserializer<'de>,
1627 {
1628 const FIELDS: &[&str] = &[
1629 "task_id",
1630 "taskId",
1631 "num_ssts_sealed",
1632 "numSstsSealed",
1633 "num_ssts_uploaded",
1634 "numSstsUploaded",
1635 "num_progress_key",
1636 "numProgressKey",
1637 "num_pending_read_io",
1638 "numPendingReadIo",
1639 "num_pending_write_io",
1640 "numPendingWriteIo",
1641 "compaction_group_id",
1642 "compactionGroupId",
1643 ];
1644
1645 #[allow(clippy::enum_variant_names)]
1646 enum GeneratedField {
1647 TaskId,
1648 NumSstsSealed,
1649 NumSstsUploaded,
1650 NumProgressKey,
1651 NumPendingReadIo,
1652 NumPendingWriteIo,
1653 CompactionGroupId,
1654 }
1655 impl<'de> serde::Deserialize<'de> for GeneratedField {
1656 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1657 where
1658 D: serde::Deserializer<'de>,
1659 {
1660 struct GeneratedVisitor;
1661
1662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1663 type Value = GeneratedField;
1664
1665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1666 write!(formatter, "expected one of: {:?}", &FIELDS)
1667 }
1668
1669 #[allow(unused_variables)]
1670 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1671 where
1672 E: serde::de::Error,
1673 {
1674 match value {
1675 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1676 "numSstsSealed" | "num_ssts_sealed" => Ok(GeneratedField::NumSstsSealed),
1677 "numSstsUploaded" | "num_ssts_uploaded" => Ok(GeneratedField::NumSstsUploaded),
1678 "numProgressKey" | "num_progress_key" => Ok(GeneratedField::NumProgressKey),
1679 "numPendingReadIo" | "num_pending_read_io" => Ok(GeneratedField::NumPendingReadIo),
1680 "numPendingWriteIo" | "num_pending_write_io" => Ok(GeneratedField::NumPendingWriteIo),
1681 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1682 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1683 }
1684 }
1685 }
1686 deserializer.deserialize_identifier(GeneratedVisitor)
1687 }
1688 }
1689 struct GeneratedVisitor;
1690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1691 type Value = CompactTaskProgress;
1692
1693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1694 formatter.write_str("struct hummock.CompactTaskProgress")
1695 }
1696
1697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskProgress, V::Error>
1698 where
1699 V: serde::de::MapAccess<'de>,
1700 {
1701 let mut task_id__ = None;
1702 let mut num_ssts_sealed__ = None;
1703 let mut num_ssts_uploaded__ = None;
1704 let mut num_progress_key__ = None;
1705 let mut num_pending_read_io__ = None;
1706 let mut num_pending_write_io__ = None;
1707 let mut compaction_group_id__ = None;
1708 while let Some(k) = map_.next_key()? {
1709 match k {
1710 GeneratedField::TaskId => {
1711 if task_id__.is_some() {
1712 return Err(serde::de::Error::duplicate_field("taskId"));
1713 }
1714 task_id__ =
1715 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1716 ;
1717 }
1718 GeneratedField::NumSstsSealed => {
1719 if num_ssts_sealed__.is_some() {
1720 return Err(serde::de::Error::duplicate_field("numSstsSealed"));
1721 }
1722 num_ssts_sealed__ =
1723 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1724 ;
1725 }
1726 GeneratedField::NumSstsUploaded => {
1727 if num_ssts_uploaded__.is_some() {
1728 return Err(serde::de::Error::duplicate_field("numSstsUploaded"));
1729 }
1730 num_ssts_uploaded__ =
1731 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1732 ;
1733 }
1734 GeneratedField::NumProgressKey => {
1735 if num_progress_key__.is_some() {
1736 return Err(serde::de::Error::duplicate_field("numProgressKey"));
1737 }
1738 num_progress_key__ =
1739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1740 ;
1741 }
1742 GeneratedField::NumPendingReadIo => {
1743 if num_pending_read_io__.is_some() {
1744 return Err(serde::de::Error::duplicate_field("numPendingReadIo"));
1745 }
1746 num_pending_read_io__ =
1747 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1748 ;
1749 }
1750 GeneratedField::NumPendingWriteIo => {
1751 if num_pending_write_io__.is_some() {
1752 return Err(serde::de::Error::duplicate_field("numPendingWriteIo"));
1753 }
1754 num_pending_write_io__ =
1755 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1756 ;
1757 }
1758 GeneratedField::CompactionGroupId => {
1759 if compaction_group_id__.is_some() {
1760 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1761 }
1762 compaction_group_id__ =
1763 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1764 ;
1765 }
1766 }
1767 }
1768 Ok(CompactTaskProgress {
1769 task_id: task_id__.unwrap_or_default(),
1770 num_ssts_sealed: num_ssts_sealed__.unwrap_or_default(),
1771 num_ssts_uploaded: num_ssts_uploaded__.unwrap_or_default(),
1772 num_progress_key: num_progress_key__.unwrap_or_default(),
1773 num_pending_read_io: num_pending_read_io__.unwrap_or_default(),
1774 num_pending_write_io: num_pending_write_io__.unwrap_or_default(),
1775 compaction_group_id: compaction_group_id__,
1776 })
1777 }
1778 }
1779 deserializer.deserialize_struct("hummock.CompactTaskProgress", FIELDS, GeneratedVisitor)
1780 }
1781}
1782impl serde::Serialize for CompactionConfig {
1783 #[allow(deprecated)]
1784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1785 where
1786 S: serde::Serializer,
1787 {
1788 use serde::ser::SerializeStruct;
1789 let mut len = 0;
1790 if self.max_bytes_for_level_base != 0 {
1791 len += 1;
1792 }
1793 if self.max_level != 0 {
1794 len += 1;
1795 }
1796 if self.max_bytes_for_level_multiplier != 0 {
1797 len += 1;
1798 }
1799 if self.max_compaction_bytes != 0 {
1800 len += 1;
1801 }
1802 if self.sub_level_max_compaction_bytes != 0 {
1803 len += 1;
1804 }
1805 if self.level0_tier_compact_file_number != 0 {
1806 len += 1;
1807 }
1808 if self.compaction_mode != 0 {
1809 len += 1;
1810 }
1811 if !self.compression_algorithm.is_empty() {
1812 len += 1;
1813 }
1814 if self.target_file_size_base != 0 {
1815 len += 1;
1816 }
1817 if self.compaction_filter_mask != 0 {
1818 len += 1;
1819 }
1820 if self.max_sub_compaction != 0 {
1821 len += 1;
1822 }
1823 if self.max_space_reclaim_bytes != 0 {
1824 len += 1;
1825 }
1826 if self.split_by_state_table {
1827 len += 1;
1828 }
1829 if self.split_weight_by_vnode != 0 {
1830 len += 1;
1831 }
1832 if self.level0_stop_write_threshold_sub_level_number != 0 {
1833 len += 1;
1834 }
1835 if self.level0_max_compact_file_number != 0 {
1836 len += 1;
1837 }
1838 if self.level0_sub_level_compact_level_count != 0 {
1839 len += 1;
1840 }
1841 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1842 len += 1;
1843 }
1844 if self.tombstone_reclaim_ratio != 0 {
1845 len += 1;
1846 }
1847 if self.enable_emergency_picker {
1848 len += 1;
1849 }
1850 if self.max_l0_compact_level_count.is_some() {
1851 len += 1;
1852 }
1853 if self.sst_allowed_trivial_move_min_size.is_some() {
1854 len += 1;
1855 }
1856 if self.disable_auto_group_scheduling.is_some() {
1857 len += 1;
1858 }
1859 if self.max_overlapping_level_size.is_some() {
1860 len += 1;
1861 }
1862 if self.emergency_level0_sst_file_count.is_some() {
1863 len += 1;
1864 }
1865 if self.emergency_level0_sub_level_partition.is_some() {
1866 len += 1;
1867 }
1868 if self.level0_stop_write_threshold_max_sst_count.is_some() {
1869 len += 1;
1870 }
1871 if self.level0_stop_write_threshold_max_size.is_some() {
1872 len += 1;
1873 }
1874 if self.sst_allowed_trivial_move_max_count.is_some() {
1875 len += 1;
1876 }
1877 if self.enable_optimize_l0_interval_selection.is_some() {
1878 len += 1;
1879 }
1880 if self.vnode_aligned_level_size_threshold.is_some() {
1881 len += 1;
1882 }
1883 if self.max_kv_count_for_xor16.is_some() {
1884 len += 1;
1885 }
1886 let mut struct_ser = serializer.serialize_struct("hummock.CompactionConfig", len)?;
1887 if self.max_bytes_for_level_base != 0 {
1888 #[allow(clippy::needless_borrow)]
1889 #[allow(clippy::needless_borrows_for_generic_args)]
1890 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&self.max_bytes_for_level_base).as_str())?;
1891 }
1892 if self.max_level != 0 {
1893 #[allow(clippy::needless_borrow)]
1894 #[allow(clippy::needless_borrows_for_generic_args)]
1895 struct_ser.serialize_field("maxLevel", ToString::to_string(&self.max_level).as_str())?;
1896 }
1897 if self.max_bytes_for_level_multiplier != 0 {
1898 #[allow(clippy::needless_borrow)]
1899 #[allow(clippy::needless_borrows_for_generic_args)]
1900 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&self.max_bytes_for_level_multiplier).as_str())?;
1901 }
1902 if self.max_compaction_bytes != 0 {
1903 #[allow(clippy::needless_borrow)]
1904 #[allow(clippy::needless_borrows_for_generic_args)]
1905 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&self.max_compaction_bytes).as_str())?;
1906 }
1907 if self.sub_level_max_compaction_bytes != 0 {
1908 #[allow(clippy::needless_borrow)]
1909 #[allow(clippy::needless_borrows_for_generic_args)]
1910 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&self.sub_level_max_compaction_bytes).as_str())?;
1911 }
1912 if self.level0_tier_compact_file_number != 0 {
1913 #[allow(clippy::needless_borrow)]
1914 #[allow(clippy::needless_borrows_for_generic_args)]
1915 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&self.level0_tier_compact_file_number).as_str())?;
1916 }
1917 if self.compaction_mode != 0 {
1918 let v = compaction_config::CompactionMode::try_from(self.compaction_mode)
1919 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compaction_mode)))?;
1920 struct_ser.serialize_field("compactionMode", &v)?;
1921 }
1922 if !self.compression_algorithm.is_empty() {
1923 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
1924 }
1925 if self.target_file_size_base != 0 {
1926 #[allow(clippy::needless_borrow)]
1927 #[allow(clippy::needless_borrows_for_generic_args)]
1928 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&self.target_file_size_base).as_str())?;
1929 }
1930 if self.compaction_filter_mask != 0 {
1931 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
1932 }
1933 if self.max_sub_compaction != 0 {
1934 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
1935 }
1936 if self.max_space_reclaim_bytes != 0 {
1937 #[allow(clippy::needless_borrow)]
1938 #[allow(clippy::needless_borrows_for_generic_args)]
1939 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&self.max_space_reclaim_bytes).as_str())?;
1940 }
1941 if self.split_by_state_table {
1942 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
1943 }
1944 if self.split_weight_by_vnode != 0 {
1945 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
1946 }
1947 if self.level0_stop_write_threshold_sub_level_number != 0 {
1948 #[allow(clippy::needless_borrow)]
1949 #[allow(clippy::needless_borrows_for_generic_args)]
1950 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&self.level0_stop_write_threshold_sub_level_number).as_str())?;
1951 }
1952 if self.level0_max_compact_file_number != 0 {
1953 #[allow(clippy::needless_borrow)]
1954 #[allow(clippy::needless_borrows_for_generic_args)]
1955 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&self.level0_max_compact_file_number).as_str())?;
1956 }
1957 if self.level0_sub_level_compact_level_count != 0 {
1958 struct_ser.serialize_field("level0SubLevelCompactLevelCount", &self.level0_sub_level_compact_level_count)?;
1959 }
1960 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1961 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", &self.level0_overlapping_sub_level_compact_level_count)?;
1962 }
1963 if self.tombstone_reclaim_ratio != 0 {
1964 struct_ser.serialize_field("tombstoneReclaimRatio", &self.tombstone_reclaim_ratio)?;
1965 }
1966 if self.enable_emergency_picker {
1967 struct_ser.serialize_field("enableEmergencyPicker", &self.enable_emergency_picker)?;
1968 }
1969 if let Some(v) = self.max_l0_compact_level_count.as_ref() {
1970 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
1971 }
1972 if let Some(v) = self.sst_allowed_trivial_move_min_size.as_ref() {
1973 #[allow(clippy::needless_borrow)]
1974 #[allow(clippy::needless_borrows_for_generic_args)]
1975 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
1976 }
1977 if let Some(v) = self.disable_auto_group_scheduling.as_ref() {
1978 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
1979 }
1980 if let Some(v) = self.max_overlapping_level_size.as_ref() {
1981 #[allow(clippy::needless_borrow)]
1982 #[allow(clippy::needless_borrows_for_generic_args)]
1983 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
1984 }
1985 if let Some(v) = self.emergency_level0_sst_file_count.as_ref() {
1986 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
1987 }
1988 if let Some(v) = self.emergency_level0_sub_level_partition.as_ref() {
1989 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
1990 }
1991 if let Some(v) = self.level0_stop_write_threshold_max_sst_count.as_ref() {
1992 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
1993 }
1994 if let Some(v) = self.level0_stop_write_threshold_max_size.as_ref() {
1995 #[allow(clippy::needless_borrow)]
1996 #[allow(clippy::needless_borrows_for_generic_args)]
1997 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
1998 }
1999 if let Some(v) = self.sst_allowed_trivial_move_max_count.as_ref() {
2000 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
2001 }
2002 if let Some(v) = self.enable_optimize_l0_interval_selection.as_ref() {
2003 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
2004 }
2005 if let Some(v) = self.vnode_aligned_level_size_threshold.as_ref() {
2006 #[allow(clippy::needless_borrow)]
2007 #[allow(clippy::needless_borrows_for_generic_args)]
2008 struct_ser.serialize_field("vnodeAlignedLevelSizeThreshold", ToString::to_string(&v).as_str())?;
2009 }
2010 if let Some(v) = self.max_kv_count_for_xor16.as_ref() {
2011 #[allow(clippy::needless_borrow)]
2012 #[allow(clippy::needless_borrows_for_generic_args)]
2013 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
2014 }
2015 struct_ser.end()
2016 }
2017}
2018impl<'de> serde::Deserialize<'de> for CompactionConfig {
2019 #[allow(deprecated)]
2020 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2021 where
2022 D: serde::Deserializer<'de>,
2023 {
2024 const FIELDS: &[&str] = &[
2025 "max_bytes_for_level_base",
2026 "maxBytesForLevelBase",
2027 "max_level",
2028 "maxLevel",
2029 "max_bytes_for_level_multiplier",
2030 "maxBytesForLevelMultiplier",
2031 "max_compaction_bytes",
2032 "maxCompactionBytes",
2033 "sub_level_max_compaction_bytes",
2034 "subLevelMaxCompactionBytes",
2035 "level0_tier_compact_file_number",
2036 "level0TierCompactFileNumber",
2037 "compaction_mode",
2038 "compactionMode",
2039 "compression_algorithm",
2040 "compressionAlgorithm",
2041 "target_file_size_base",
2042 "targetFileSizeBase",
2043 "compaction_filter_mask",
2044 "compactionFilterMask",
2045 "max_sub_compaction",
2046 "maxSubCompaction",
2047 "max_space_reclaim_bytes",
2048 "maxSpaceReclaimBytes",
2049 "split_by_state_table",
2050 "splitByStateTable",
2051 "split_weight_by_vnode",
2052 "splitWeightByVnode",
2053 "level0_stop_write_threshold_sub_level_number",
2054 "level0StopWriteThresholdSubLevelNumber",
2055 "level0_max_compact_file_number",
2056 "level0MaxCompactFileNumber",
2057 "level0_sub_level_compact_level_count",
2058 "level0SubLevelCompactLevelCount",
2059 "level0_overlapping_sub_level_compact_level_count",
2060 "level0OverlappingSubLevelCompactLevelCount",
2061 "tombstone_reclaim_ratio",
2062 "tombstoneReclaimRatio",
2063 "enable_emergency_picker",
2064 "enableEmergencyPicker",
2065 "max_l0_compact_level_count",
2066 "maxL0CompactLevelCount",
2067 "sst_allowed_trivial_move_min_size",
2068 "sstAllowedTrivialMoveMinSize",
2069 "disable_auto_group_scheduling",
2070 "disableAutoGroupScheduling",
2071 "max_overlapping_level_size",
2072 "maxOverlappingLevelSize",
2073 "emergency_level0_sst_file_count",
2074 "emergencyLevel0SstFileCount",
2075 "emergency_level0_sub_level_partition",
2076 "emergencyLevel0SubLevelPartition",
2077 "level0_stop_write_threshold_max_sst_count",
2078 "level0StopWriteThresholdMaxSstCount",
2079 "level0_stop_write_threshold_max_size",
2080 "level0StopWriteThresholdMaxSize",
2081 "sst_allowed_trivial_move_max_count",
2082 "sstAllowedTrivialMoveMaxCount",
2083 "enable_optimize_l0_interval_selection",
2084 "enableOptimizeL0IntervalSelection",
2085 "vnode_aligned_level_size_threshold",
2086 "vnodeAlignedLevelSizeThreshold",
2087 "max_kv_count_for_xor16",
2088 "maxKvCountForXor16",
2089 ];
2090
2091 #[allow(clippy::enum_variant_names)]
2092 enum GeneratedField {
2093 MaxBytesForLevelBase,
2094 MaxLevel,
2095 MaxBytesForLevelMultiplier,
2096 MaxCompactionBytes,
2097 SubLevelMaxCompactionBytes,
2098 Level0TierCompactFileNumber,
2099 CompactionMode,
2100 CompressionAlgorithm,
2101 TargetFileSizeBase,
2102 CompactionFilterMask,
2103 MaxSubCompaction,
2104 MaxSpaceReclaimBytes,
2105 SplitByStateTable,
2106 SplitWeightByVnode,
2107 Level0StopWriteThresholdSubLevelNumber,
2108 Level0MaxCompactFileNumber,
2109 Level0SubLevelCompactLevelCount,
2110 Level0OverlappingSubLevelCompactLevelCount,
2111 TombstoneReclaimRatio,
2112 EnableEmergencyPicker,
2113 MaxL0CompactLevelCount,
2114 SstAllowedTrivialMoveMinSize,
2115 DisableAutoGroupScheduling,
2116 MaxOverlappingLevelSize,
2117 EmergencyLevel0SstFileCount,
2118 EmergencyLevel0SubLevelPartition,
2119 Level0StopWriteThresholdMaxSstCount,
2120 Level0StopWriteThresholdMaxSize,
2121 SstAllowedTrivialMoveMaxCount,
2122 EnableOptimizeL0IntervalSelection,
2123 VnodeAlignedLevelSizeThreshold,
2124 MaxKvCountForXor16,
2125 }
2126 impl<'de> serde::Deserialize<'de> for GeneratedField {
2127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2128 where
2129 D: serde::Deserializer<'de>,
2130 {
2131 struct GeneratedVisitor;
2132
2133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2134 type Value = GeneratedField;
2135
2136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2137 write!(formatter, "expected one of: {:?}", &FIELDS)
2138 }
2139
2140 #[allow(unused_variables)]
2141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2142 where
2143 E: serde::de::Error,
2144 {
2145 match value {
2146 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
2147 "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2148 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
2149 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
2150 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
2151 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
2152 "compactionMode" | "compaction_mode" => Ok(GeneratedField::CompactionMode),
2153 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
2154 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
2155 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
2156 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
2157 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
2158 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
2159 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
2160 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
2161 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
2162 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
2163 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
2164 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
2165 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
2166 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
2167 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
2168 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
2169 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
2170 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
2171 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
2172 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
2173 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
2174 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
2175 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
2176 "vnodeAlignedLevelSizeThreshold" | "vnode_aligned_level_size_threshold" => Ok(GeneratedField::VnodeAlignedLevelSizeThreshold),
2177 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
2178 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2179 }
2180 }
2181 }
2182 deserializer.deserialize_identifier(GeneratedVisitor)
2183 }
2184 }
2185 struct GeneratedVisitor;
2186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2187 type Value = CompactionConfig;
2188
2189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2190 formatter.write_str("struct hummock.CompactionConfig")
2191 }
2192
2193 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionConfig, V::Error>
2194 where
2195 V: serde::de::MapAccess<'de>,
2196 {
2197 let mut max_bytes_for_level_base__ = None;
2198 let mut max_level__ = None;
2199 let mut max_bytes_for_level_multiplier__ = None;
2200 let mut max_compaction_bytes__ = None;
2201 let mut sub_level_max_compaction_bytes__ = None;
2202 let mut level0_tier_compact_file_number__ = None;
2203 let mut compaction_mode__ = None;
2204 let mut compression_algorithm__ = None;
2205 let mut target_file_size_base__ = None;
2206 let mut compaction_filter_mask__ = None;
2207 let mut max_sub_compaction__ = None;
2208 let mut max_space_reclaim_bytes__ = None;
2209 let mut split_by_state_table__ = None;
2210 let mut split_weight_by_vnode__ = None;
2211 let mut level0_stop_write_threshold_sub_level_number__ = None;
2212 let mut level0_max_compact_file_number__ = None;
2213 let mut level0_sub_level_compact_level_count__ = None;
2214 let mut level0_overlapping_sub_level_compact_level_count__ = None;
2215 let mut tombstone_reclaim_ratio__ = None;
2216 let mut enable_emergency_picker__ = None;
2217 let mut max_l0_compact_level_count__ = None;
2218 let mut sst_allowed_trivial_move_min_size__ = None;
2219 let mut disable_auto_group_scheduling__ = None;
2220 let mut max_overlapping_level_size__ = None;
2221 let mut emergency_level0_sst_file_count__ = None;
2222 let mut emergency_level0_sub_level_partition__ = None;
2223 let mut level0_stop_write_threshold_max_sst_count__ = None;
2224 let mut level0_stop_write_threshold_max_size__ = None;
2225 let mut sst_allowed_trivial_move_max_count__ = None;
2226 let mut enable_optimize_l0_interval_selection__ = None;
2227 let mut vnode_aligned_level_size_threshold__ = None;
2228 let mut max_kv_count_for_xor16__ = None;
2229 while let Some(k) = map_.next_key()? {
2230 match k {
2231 GeneratedField::MaxBytesForLevelBase => {
2232 if max_bytes_for_level_base__.is_some() {
2233 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
2234 }
2235 max_bytes_for_level_base__ =
2236 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2237 ;
2238 }
2239 GeneratedField::MaxLevel => {
2240 if max_level__.is_some() {
2241 return Err(serde::de::Error::duplicate_field("maxLevel"));
2242 }
2243 max_level__ =
2244 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2245 ;
2246 }
2247 GeneratedField::MaxBytesForLevelMultiplier => {
2248 if max_bytes_for_level_multiplier__.is_some() {
2249 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
2250 }
2251 max_bytes_for_level_multiplier__ =
2252 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2253 ;
2254 }
2255 GeneratedField::MaxCompactionBytes => {
2256 if max_compaction_bytes__.is_some() {
2257 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
2258 }
2259 max_compaction_bytes__ =
2260 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2261 ;
2262 }
2263 GeneratedField::SubLevelMaxCompactionBytes => {
2264 if sub_level_max_compaction_bytes__.is_some() {
2265 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
2266 }
2267 sub_level_max_compaction_bytes__ =
2268 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2269 ;
2270 }
2271 GeneratedField::Level0TierCompactFileNumber => {
2272 if level0_tier_compact_file_number__.is_some() {
2273 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
2274 }
2275 level0_tier_compact_file_number__ =
2276 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2277 ;
2278 }
2279 GeneratedField::CompactionMode => {
2280 if compaction_mode__.is_some() {
2281 return Err(serde::de::Error::duplicate_field("compactionMode"));
2282 }
2283 compaction_mode__ = Some(map_.next_value::<compaction_config::CompactionMode>()? as i32);
2284 }
2285 GeneratedField::CompressionAlgorithm => {
2286 if compression_algorithm__.is_some() {
2287 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
2288 }
2289 compression_algorithm__ = Some(map_.next_value()?);
2290 }
2291 GeneratedField::TargetFileSizeBase => {
2292 if target_file_size_base__.is_some() {
2293 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
2294 }
2295 target_file_size_base__ =
2296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2297 ;
2298 }
2299 GeneratedField::CompactionFilterMask => {
2300 if compaction_filter_mask__.is_some() {
2301 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
2302 }
2303 compaction_filter_mask__ =
2304 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2305 ;
2306 }
2307 GeneratedField::MaxSubCompaction => {
2308 if max_sub_compaction__.is_some() {
2309 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
2310 }
2311 max_sub_compaction__ =
2312 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2313 ;
2314 }
2315 GeneratedField::MaxSpaceReclaimBytes => {
2316 if max_space_reclaim_bytes__.is_some() {
2317 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
2318 }
2319 max_space_reclaim_bytes__ =
2320 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2321 ;
2322 }
2323 GeneratedField::SplitByStateTable => {
2324 if split_by_state_table__.is_some() {
2325 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
2326 }
2327 split_by_state_table__ = Some(map_.next_value()?);
2328 }
2329 GeneratedField::SplitWeightByVnode => {
2330 if split_weight_by_vnode__.is_some() {
2331 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
2332 }
2333 split_weight_by_vnode__ =
2334 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2335 ;
2336 }
2337 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
2338 if level0_stop_write_threshold_sub_level_number__.is_some() {
2339 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
2340 }
2341 level0_stop_write_threshold_sub_level_number__ =
2342 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2343 ;
2344 }
2345 GeneratedField::Level0MaxCompactFileNumber => {
2346 if level0_max_compact_file_number__.is_some() {
2347 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
2348 }
2349 level0_max_compact_file_number__ =
2350 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2351 ;
2352 }
2353 GeneratedField::Level0SubLevelCompactLevelCount => {
2354 if level0_sub_level_compact_level_count__.is_some() {
2355 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
2356 }
2357 level0_sub_level_compact_level_count__ =
2358 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2359 ;
2360 }
2361 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
2362 if level0_overlapping_sub_level_compact_level_count__.is_some() {
2363 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
2364 }
2365 level0_overlapping_sub_level_compact_level_count__ =
2366 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2367 ;
2368 }
2369 GeneratedField::TombstoneReclaimRatio => {
2370 if tombstone_reclaim_ratio__.is_some() {
2371 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
2372 }
2373 tombstone_reclaim_ratio__ =
2374 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2375 ;
2376 }
2377 GeneratedField::EnableEmergencyPicker => {
2378 if enable_emergency_picker__.is_some() {
2379 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
2380 }
2381 enable_emergency_picker__ = Some(map_.next_value()?);
2382 }
2383 GeneratedField::MaxL0CompactLevelCount => {
2384 if max_l0_compact_level_count__.is_some() {
2385 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
2386 }
2387 max_l0_compact_level_count__ =
2388 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2389 ;
2390 }
2391 GeneratedField::SstAllowedTrivialMoveMinSize => {
2392 if sst_allowed_trivial_move_min_size__.is_some() {
2393 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
2394 }
2395 sst_allowed_trivial_move_min_size__ =
2396 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2397 ;
2398 }
2399 GeneratedField::DisableAutoGroupScheduling => {
2400 if disable_auto_group_scheduling__.is_some() {
2401 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
2402 }
2403 disable_auto_group_scheduling__ = map_.next_value()?;
2404 }
2405 GeneratedField::MaxOverlappingLevelSize => {
2406 if max_overlapping_level_size__.is_some() {
2407 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
2408 }
2409 max_overlapping_level_size__ =
2410 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2411 ;
2412 }
2413 GeneratedField::EmergencyLevel0SstFileCount => {
2414 if emergency_level0_sst_file_count__.is_some() {
2415 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
2416 }
2417 emergency_level0_sst_file_count__ =
2418 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2419 ;
2420 }
2421 GeneratedField::EmergencyLevel0SubLevelPartition => {
2422 if emergency_level0_sub_level_partition__.is_some() {
2423 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
2424 }
2425 emergency_level0_sub_level_partition__ =
2426 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2427 ;
2428 }
2429 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
2430 if level0_stop_write_threshold_max_sst_count__.is_some() {
2431 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
2432 }
2433 level0_stop_write_threshold_max_sst_count__ =
2434 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2435 ;
2436 }
2437 GeneratedField::Level0StopWriteThresholdMaxSize => {
2438 if level0_stop_write_threshold_max_size__.is_some() {
2439 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
2440 }
2441 level0_stop_write_threshold_max_size__ =
2442 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2443 ;
2444 }
2445 GeneratedField::SstAllowedTrivialMoveMaxCount => {
2446 if sst_allowed_trivial_move_max_count__.is_some() {
2447 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
2448 }
2449 sst_allowed_trivial_move_max_count__ =
2450 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2451 ;
2452 }
2453 GeneratedField::EnableOptimizeL0IntervalSelection => {
2454 if enable_optimize_l0_interval_selection__.is_some() {
2455 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
2456 }
2457 enable_optimize_l0_interval_selection__ = map_.next_value()?;
2458 }
2459 GeneratedField::VnodeAlignedLevelSizeThreshold => {
2460 if vnode_aligned_level_size_threshold__.is_some() {
2461 return Err(serde::de::Error::duplicate_field("vnodeAlignedLevelSizeThreshold"));
2462 }
2463 vnode_aligned_level_size_threshold__ =
2464 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2465 ;
2466 }
2467 GeneratedField::MaxKvCountForXor16 => {
2468 if max_kv_count_for_xor16__.is_some() {
2469 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
2470 }
2471 max_kv_count_for_xor16__ =
2472 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2473 ;
2474 }
2475 }
2476 }
2477 Ok(CompactionConfig {
2478 max_bytes_for_level_base: max_bytes_for_level_base__.unwrap_or_default(),
2479 max_level: max_level__.unwrap_or_default(),
2480 max_bytes_for_level_multiplier: max_bytes_for_level_multiplier__.unwrap_or_default(),
2481 max_compaction_bytes: max_compaction_bytes__.unwrap_or_default(),
2482 sub_level_max_compaction_bytes: sub_level_max_compaction_bytes__.unwrap_or_default(),
2483 level0_tier_compact_file_number: level0_tier_compact_file_number__.unwrap_or_default(),
2484 compaction_mode: compaction_mode__.unwrap_or_default(),
2485 compression_algorithm: compression_algorithm__.unwrap_or_default(),
2486 target_file_size_base: target_file_size_base__.unwrap_or_default(),
2487 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
2488 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
2489 max_space_reclaim_bytes: max_space_reclaim_bytes__.unwrap_or_default(),
2490 split_by_state_table: split_by_state_table__.unwrap_or_default(),
2491 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
2492 level0_stop_write_threshold_sub_level_number: level0_stop_write_threshold_sub_level_number__.unwrap_or_default(),
2493 level0_max_compact_file_number: level0_max_compact_file_number__.unwrap_or_default(),
2494 level0_sub_level_compact_level_count: level0_sub_level_compact_level_count__.unwrap_or_default(),
2495 level0_overlapping_sub_level_compact_level_count: level0_overlapping_sub_level_compact_level_count__.unwrap_or_default(),
2496 tombstone_reclaim_ratio: tombstone_reclaim_ratio__.unwrap_or_default(),
2497 enable_emergency_picker: enable_emergency_picker__.unwrap_or_default(),
2498 max_l0_compact_level_count: max_l0_compact_level_count__,
2499 sst_allowed_trivial_move_min_size: sst_allowed_trivial_move_min_size__,
2500 disable_auto_group_scheduling: disable_auto_group_scheduling__,
2501 max_overlapping_level_size: max_overlapping_level_size__,
2502 emergency_level0_sst_file_count: emergency_level0_sst_file_count__,
2503 emergency_level0_sub_level_partition: emergency_level0_sub_level_partition__,
2504 level0_stop_write_threshold_max_sst_count: level0_stop_write_threshold_max_sst_count__,
2505 level0_stop_write_threshold_max_size: level0_stop_write_threshold_max_size__,
2506 sst_allowed_trivial_move_max_count: sst_allowed_trivial_move_max_count__,
2507 enable_optimize_l0_interval_selection: enable_optimize_l0_interval_selection__,
2508 vnode_aligned_level_size_threshold: vnode_aligned_level_size_threshold__,
2509 max_kv_count_for_xor16: max_kv_count_for_xor16__,
2510 })
2511 }
2512 }
2513 deserializer.deserialize_struct("hummock.CompactionConfig", FIELDS, GeneratedVisitor)
2514 }
2515}
2516impl serde::Serialize for compaction_config::CompactionMode {
2517 #[allow(deprecated)]
2518 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2519 where
2520 S: serde::Serializer,
2521 {
2522 let variant = match self {
2523 Self::Unspecified => "UNSPECIFIED",
2524 Self::Range => "RANGE",
2525 };
2526 serializer.serialize_str(variant)
2527 }
2528}
2529impl<'de> serde::Deserialize<'de> for compaction_config::CompactionMode {
2530 #[allow(deprecated)]
2531 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2532 where
2533 D: serde::Deserializer<'de>,
2534 {
2535 const FIELDS: &[&str] = &[
2536 "UNSPECIFIED",
2537 "RANGE",
2538 ];
2539
2540 struct GeneratedVisitor;
2541
2542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2543 type Value = compaction_config::CompactionMode;
2544
2545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2546 write!(formatter, "expected one of: {:?}", &FIELDS)
2547 }
2548
2549 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2550 where
2551 E: serde::de::Error,
2552 {
2553 i32::try_from(v)
2554 .ok()
2555 .and_then(|x| x.try_into().ok())
2556 .ok_or_else(|| {
2557 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2558 })
2559 }
2560
2561 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2562 where
2563 E: serde::de::Error,
2564 {
2565 i32::try_from(v)
2566 .ok()
2567 .and_then(|x| x.try_into().ok())
2568 .ok_or_else(|| {
2569 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2570 })
2571 }
2572
2573 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2574 where
2575 E: serde::de::Error,
2576 {
2577 match value {
2578 "UNSPECIFIED" => Ok(compaction_config::CompactionMode::Unspecified),
2579 "RANGE" => Ok(compaction_config::CompactionMode::Range),
2580 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2581 }
2582 }
2583 }
2584 deserializer.deserialize_any(GeneratedVisitor)
2585 }
2586}
2587impl serde::Serialize for CompactionGroup {
2588 #[allow(deprecated)]
2589 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2590 where
2591 S: serde::Serializer,
2592 {
2593 use serde::ser::SerializeStruct;
2594 let mut len = 0;
2595 if self.id != 0 {
2596 len += 1;
2597 }
2598 if self.compaction_config.is_some() {
2599 len += 1;
2600 }
2601 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroup", len)?;
2602 if self.id != 0 {
2603 #[allow(clippy::needless_borrow)]
2604 #[allow(clippy::needless_borrows_for_generic_args)]
2605 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2606 }
2607 if let Some(v) = self.compaction_config.as_ref() {
2608 struct_ser.serialize_field("compactionConfig", v)?;
2609 }
2610 struct_ser.end()
2611 }
2612}
2613impl<'de> serde::Deserialize<'de> for CompactionGroup {
2614 #[allow(deprecated)]
2615 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2616 where
2617 D: serde::Deserializer<'de>,
2618 {
2619 const FIELDS: &[&str] = &[
2620 "id",
2621 "compaction_config",
2622 "compactionConfig",
2623 ];
2624
2625 #[allow(clippy::enum_variant_names)]
2626 enum GeneratedField {
2627 Id,
2628 CompactionConfig,
2629 }
2630 impl<'de> serde::Deserialize<'de> for GeneratedField {
2631 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2632 where
2633 D: serde::Deserializer<'de>,
2634 {
2635 struct GeneratedVisitor;
2636
2637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2638 type Value = GeneratedField;
2639
2640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2641 write!(formatter, "expected one of: {:?}", &FIELDS)
2642 }
2643
2644 #[allow(unused_variables)]
2645 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2646 where
2647 E: serde::de::Error,
2648 {
2649 match value {
2650 "id" => Ok(GeneratedField::Id),
2651 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2653 }
2654 }
2655 }
2656 deserializer.deserialize_identifier(GeneratedVisitor)
2657 }
2658 }
2659 struct GeneratedVisitor;
2660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2661 type Value = CompactionGroup;
2662
2663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2664 formatter.write_str("struct hummock.CompactionGroup")
2665 }
2666
2667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroup, V::Error>
2668 where
2669 V: serde::de::MapAccess<'de>,
2670 {
2671 let mut id__ = None;
2672 let mut compaction_config__ = None;
2673 while let Some(k) = map_.next_key()? {
2674 match k {
2675 GeneratedField::Id => {
2676 if id__.is_some() {
2677 return Err(serde::de::Error::duplicate_field("id"));
2678 }
2679 id__ =
2680 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2681 ;
2682 }
2683 GeneratedField::CompactionConfig => {
2684 if compaction_config__.is_some() {
2685 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2686 }
2687 compaction_config__ = map_.next_value()?;
2688 }
2689 }
2690 }
2691 Ok(CompactionGroup {
2692 id: id__.unwrap_or_default(),
2693 compaction_config: compaction_config__,
2694 })
2695 }
2696 }
2697 deserializer.deserialize_struct("hummock.CompactionGroup", FIELDS, GeneratedVisitor)
2698 }
2699}
2700impl serde::Serialize for CompactionGroupInfo {
2701 #[allow(deprecated)]
2702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2703 where
2704 S: serde::Serializer,
2705 {
2706 use serde::ser::SerializeStruct;
2707 let mut len = 0;
2708 if self.id != 0 {
2709 len += 1;
2710 }
2711 if self.parent_id != 0 {
2712 len += 1;
2713 }
2714 if !self.member_table_ids.is_empty() {
2715 len += 1;
2716 }
2717 if self.compaction_config.is_some() {
2718 len += 1;
2719 }
2720 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroupInfo", len)?;
2721 if self.id != 0 {
2722 #[allow(clippy::needless_borrow)]
2723 #[allow(clippy::needless_borrows_for_generic_args)]
2724 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2725 }
2726 if self.parent_id != 0 {
2727 #[allow(clippy::needless_borrow)]
2728 #[allow(clippy::needless_borrows_for_generic_args)]
2729 struct_ser.serialize_field("parentId", ToString::to_string(&self.parent_id).as_str())?;
2730 }
2731 if !self.member_table_ids.is_empty() {
2732 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
2733 }
2734 if let Some(v) = self.compaction_config.as_ref() {
2735 struct_ser.serialize_field("compactionConfig", v)?;
2736 }
2737 struct_ser.end()
2738 }
2739}
2740impl<'de> serde::Deserialize<'de> for CompactionGroupInfo {
2741 #[allow(deprecated)]
2742 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2743 where
2744 D: serde::Deserializer<'de>,
2745 {
2746 const FIELDS: &[&str] = &[
2747 "id",
2748 "parent_id",
2749 "parentId",
2750 "member_table_ids",
2751 "memberTableIds",
2752 "compaction_config",
2753 "compactionConfig",
2754 ];
2755
2756 #[allow(clippy::enum_variant_names)]
2757 enum GeneratedField {
2758 Id,
2759 ParentId,
2760 MemberTableIds,
2761 CompactionConfig,
2762 }
2763 impl<'de> serde::Deserialize<'de> for GeneratedField {
2764 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2765 where
2766 D: serde::Deserializer<'de>,
2767 {
2768 struct GeneratedVisitor;
2769
2770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2771 type Value = GeneratedField;
2772
2773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2774 write!(formatter, "expected one of: {:?}", &FIELDS)
2775 }
2776
2777 #[allow(unused_variables)]
2778 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2779 where
2780 E: serde::de::Error,
2781 {
2782 match value {
2783 "id" => Ok(GeneratedField::Id),
2784 "parentId" | "parent_id" => Ok(GeneratedField::ParentId),
2785 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
2786 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2787 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2788 }
2789 }
2790 }
2791 deserializer.deserialize_identifier(GeneratedVisitor)
2792 }
2793 }
2794 struct GeneratedVisitor;
2795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2796 type Value = CompactionGroupInfo;
2797
2798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2799 formatter.write_str("struct hummock.CompactionGroupInfo")
2800 }
2801
2802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroupInfo, V::Error>
2803 where
2804 V: serde::de::MapAccess<'de>,
2805 {
2806 let mut id__ = None;
2807 let mut parent_id__ = None;
2808 let mut member_table_ids__ = None;
2809 let mut compaction_config__ = None;
2810 while let Some(k) = map_.next_key()? {
2811 match k {
2812 GeneratedField::Id => {
2813 if id__.is_some() {
2814 return Err(serde::de::Error::duplicate_field("id"));
2815 }
2816 id__ =
2817 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2818 ;
2819 }
2820 GeneratedField::ParentId => {
2821 if parent_id__.is_some() {
2822 return Err(serde::de::Error::duplicate_field("parentId"));
2823 }
2824 parent_id__ =
2825 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2826 ;
2827 }
2828 GeneratedField::MemberTableIds => {
2829 if member_table_ids__.is_some() {
2830 return Err(serde::de::Error::duplicate_field("memberTableIds"));
2831 }
2832 member_table_ids__ =
2833 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2834 .into_iter().map(|x| x.0).collect())
2835 ;
2836 }
2837 GeneratedField::CompactionConfig => {
2838 if compaction_config__.is_some() {
2839 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2840 }
2841 compaction_config__ = map_.next_value()?;
2842 }
2843 }
2844 }
2845 Ok(CompactionGroupInfo {
2846 id: id__.unwrap_or_default(),
2847 parent_id: parent_id__.unwrap_or_default(),
2848 member_table_ids: member_table_ids__.unwrap_or_default(),
2849 compaction_config: compaction_config__,
2850 })
2851 }
2852 }
2853 deserializer.deserialize_struct("hummock.CompactionGroupInfo", FIELDS, GeneratedVisitor)
2854 }
2855}
2856impl serde::Serialize for CompatibilityVersion {
2857 #[allow(deprecated)]
2858 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2859 where
2860 S: serde::Serializer,
2861 {
2862 let variant = match self {
2863 Self::VersionUnspecified => "VERSION_UNSPECIFIED",
2864 Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
2865 Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
2866 Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
2867 };
2868 serializer.serialize_str(variant)
2869 }
2870}
2871impl<'de> serde::Deserialize<'de> for CompatibilityVersion {
2872 #[allow(deprecated)]
2873 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2874 where
2875 D: serde::Deserializer<'de>,
2876 {
2877 const FIELDS: &[&str] = &[
2878 "VERSION_UNSPECIFIED",
2879 "NO_TRIVIAL_SPLIT",
2880 "NO_MEMBER_TABLE_IDS",
2881 "SPLIT_GROUP_BY_TABLE_ID",
2882 ];
2883
2884 struct GeneratedVisitor;
2885
2886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2887 type Value = CompatibilityVersion;
2888
2889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2890 write!(formatter, "expected one of: {:?}", &FIELDS)
2891 }
2892
2893 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2894 where
2895 E: serde::de::Error,
2896 {
2897 i32::try_from(v)
2898 .ok()
2899 .and_then(|x| x.try_into().ok())
2900 .ok_or_else(|| {
2901 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2902 })
2903 }
2904
2905 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2906 where
2907 E: serde::de::Error,
2908 {
2909 i32::try_from(v)
2910 .ok()
2911 .and_then(|x| x.try_into().ok())
2912 .ok_or_else(|| {
2913 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2914 })
2915 }
2916
2917 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2918 where
2919 E: serde::de::Error,
2920 {
2921 match value {
2922 "VERSION_UNSPECIFIED" => Ok(CompatibilityVersion::VersionUnspecified),
2923 "NO_TRIVIAL_SPLIT" => Ok(CompatibilityVersion::NoTrivialSplit),
2924 "NO_MEMBER_TABLE_IDS" => Ok(CompatibilityVersion::NoMemberTableIds),
2925 "SPLIT_GROUP_BY_TABLE_ID" => Ok(CompatibilityVersion::SplitGroupByTableId),
2926 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2927 }
2928 }
2929 }
2930 deserializer.deserialize_any(GeneratedVisitor)
2931 }
2932}
2933impl serde::Serialize for DisableCommitEpochRequest {
2934 #[allow(deprecated)]
2935 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2936 where
2937 S: serde::Serializer,
2938 {
2939 use serde::ser::SerializeStruct;
2940 let len = 0;
2941 let struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochRequest", len)?;
2942 struct_ser.end()
2943 }
2944}
2945impl<'de> serde::Deserialize<'de> for DisableCommitEpochRequest {
2946 #[allow(deprecated)]
2947 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2948 where
2949 D: serde::Deserializer<'de>,
2950 {
2951 const FIELDS: &[&str] = &[
2952 ];
2953
2954 #[allow(clippy::enum_variant_names)]
2955 enum GeneratedField {
2956 }
2957 impl<'de> serde::Deserialize<'de> for GeneratedField {
2958 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2959 where
2960 D: serde::Deserializer<'de>,
2961 {
2962 struct GeneratedVisitor;
2963
2964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2965 type Value = GeneratedField;
2966
2967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2968 write!(formatter, "expected one of: {:?}", &FIELDS)
2969 }
2970
2971 #[allow(unused_variables)]
2972 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2973 where
2974 E: serde::de::Error,
2975 {
2976 Err(serde::de::Error::unknown_field(value, FIELDS))
2977 }
2978 }
2979 deserializer.deserialize_identifier(GeneratedVisitor)
2980 }
2981 }
2982 struct GeneratedVisitor;
2983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2984 type Value = DisableCommitEpochRequest;
2985
2986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2987 formatter.write_str("struct hummock.DisableCommitEpochRequest")
2988 }
2989
2990 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochRequest, V::Error>
2991 where
2992 V: serde::de::MapAccess<'de>,
2993 {
2994 while map_.next_key::<GeneratedField>()?.is_some() {
2995 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2996 }
2997 Ok(DisableCommitEpochRequest {
2998 })
2999 }
3000 }
3001 deserializer.deserialize_struct("hummock.DisableCommitEpochRequest", FIELDS, GeneratedVisitor)
3002 }
3003}
3004impl serde::Serialize for DisableCommitEpochResponse {
3005 #[allow(deprecated)]
3006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3007 where
3008 S: serde::Serializer,
3009 {
3010 use serde::ser::SerializeStruct;
3011 let mut len = 0;
3012 if self.current_version.is_some() {
3013 len += 1;
3014 }
3015 let mut struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochResponse", len)?;
3016 if let Some(v) = self.current_version.as_ref() {
3017 struct_ser.serialize_field("currentVersion", v)?;
3018 }
3019 struct_ser.end()
3020 }
3021}
3022impl<'de> serde::Deserialize<'de> for DisableCommitEpochResponse {
3023 #[allow(deprecated)]
3024 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3025 where
3026 D: serde::Deserializer<'de>,
3027 {
3028 const FIELDS: &[&str] = &[
3029 "current_version",
3030 "currentVersion",
3031 ];
3032
3033 #[allow(clippy::enum_variant_names)]
3034 enum GeneratedField {
3035 CurrentVersion,
3036 }
3037 impl<'de> serde::Deserialize<'de> for GeneratedField {
3038 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3039 where
3040 D: serde::Deserializer<'de>,
3041 {
3042 struct GeneratedVisitor;
3043
3044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3045 type Value = GeneratedField;
3046
3047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3048 write!(formatter, "expected one of: {:?}", &FIELDS)
3049 }
3050
3051 #[allow(unused_variables)]
3052 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3053 where
3054 E: serde::de::Error,
3055 {
3056 match value {
3057 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
3058 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3059 }
3060 }
3061 }
3062 deserializer.deserialize_identifier(GeneratedVisitor)
3063 }
3064 }
3065 struct GeneratedVisitor;
3066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3067 type Value = DisableCommitEpochResponse;
3068
3069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3070 formatter.write_str("struct hummock.DisableCommitEpochResponse")
3071 }
3072
3073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochResponse, V::Error>
3074 where
3075 V: serde::de::MapAccess<'de>,
3076 {
3077 let mut current_version__ = None;
3078 while let Some(k) = map_.next_key()? {
3079 match k {
3080 GeneratedField::CurrentVersion => {
3081 if current_version__.is_some() {
3082 return Err(serde::de::Error::duplicate_field("currentVersion"));
3083 }
3084 current_version__ = map_.next_value()?;
3085 }
3086 }
3087 }
3088 Ok(DisableCommitEpochResponse {
3089 current_version: current_version__,
3090 })
3091 }
3092 }
3093 deserializer.deserialize_struct("hummock.DisableCommitEpochResponse", FIELDS, GeneratedVisitor)
3094 }
3095}
3096impl serde::Serialize for EpochNewChangeLog {
3097 #[allow(deprecated)]
3098 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3099 where
3100 S: serde::Serializer,
3101 {
3102 use serde::ser::SerializeStruct;
3103 let mut len = 0;
3104 if !self.old_value.is_empty() {
3105 len += 1;
3106 }
3107 if !self.new_value.is_empty() {
3108 len += 1;
3109 }
3110 if !self.epochs.is_empty() {
3111 len += 1;
3112 }
3113 let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3114 if !self.old_value.is_empty() {
3115 struct_ser.serialize_field("oldValue", &self.old_value)?;
3116 }
3117 if !self.new_value.is_empty() {
3118 struct_ser.serialize_field("newValue", &self.new_value)?;
3119 }
3120 if !self.epochs.is_empty() {
3121 struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3122 }
3123 struct_ser.end()
3124 }
3125}
3126impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3127 #[allow(deprecated)]
3128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3129 where
3130 D: serde::Deserializer<'de>,
3131 {
3132 const FIELDS: &[&str] = &[
3133 "old_value",
3134 "oldValue",
3135 "new_value",
3136 "newValue",
3137 "epochs",
3138 ];
3139
3140 #[allow(clippy::enum_variant_names)]
3141 enum GeneratedField {
3142 OldValue,
3143 NewValue,
3144 Epochs,
3145 }
3146 impl<'de> serde::Deserialize<'de> for GeneratedField {
3147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3148 where
3149 D: serde::Deserializer<'de>,
3150 {
3151 struct GeneratedVisitor;
3152
3153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3154 type Value = GeneratedField;
3155
3156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3157 write!(formatter, "expected one of: {:?}", &FIELDS)
3158 }
3159
3160 #[allow(unused_variables)]
3161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3162 where
3163 E: serde::de::Error,
3164 {
3165 match value {
3166 "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3167 "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3168 "epochs" => Ok(GeneratedField::Epochs),
3169 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3170 }
3171 }
3172 }
3173 deserializer.deserialize_identifier(GeneratedVisitor)
3174 }
3175 }
3176 struct GeneratedVisitor;
3177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3178 type Value = EpochNewChangeLog;
3179
3180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3181 formatter.write_str("struct hummock.EpochNewChangeLog")
3182 }
3183
3184 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3185 where
3186 V: serde::de::MapAccess<'de>,
3187 {
3188 let mut old_value__ = None;
3189 let mut new_value__ = None;
3190 let mut epochs__ = None;
3191 while let Some(k) = map_.next_key()? {
3192 match k {
3193 GeneratedField::OldValue => {
3194 if old_value__.is_some() {
3195 return Err(serde::de::Error::duplicate_field("oldValue"));
3196 }
3197 old_value__ = Some(map_.next_value()?);
3198 }
3199 GeneratedField::NewValue => {
3200 if new_value__.is_some() {
3201 return Err(serde::de::Error::duplicate_field("newValue"));
3202 }
3203 new_value__ = Some(map_.next_value()?);
3204 }
3205 GeneratedField::Epochs => {
3206 if epochs__.is_some() {
3207 return Err(serde::de::Error::duplicate_field("epochs"));
3208 }
3209 epochs__ =
3210 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3211 .into_iter().map(|x| x.0).collect())
3212 ;
3213 }
3214 }
3215 }
3216 Ok(EpochNewChangeLog {
3217 old_value: old_value__.unwrap_or_default(),
3218 new_value: new_value__.unwrap_or_default(),
3219 epochs: epochs__.unwrap_or_default(),
3220 })
3221 }
3222 }
3223 deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3224 }
3225}
3226impl serde::Serialize for FlatIndex {
3227 #[allow(deprecated)]
3228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3229 where
3230 S: serde::Serializer,
3231 {
3232 use serde::ser::SerializeStruct;
3233 let mut len = 0;
3234 if self.config.is_some() {
3235 len += 1;
3236 }
3237 if !self.vector_files.is_empty() {
3238 len += 1;
3239 }
3240 if self.next_vector_id != 0 {
3241 len += 1;
3242 }
3243 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3244 if let Some(v) = self.config.as_ref() {
3245 struct_ser.serialize_field("config", v)?;
3246 }
3247 if !self.vector_files.is_empty() {
3248 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3249 }
3250 if self.next_vector_id != 0 {
3251 #[allow(clippy::needless_borrow)]
3252 #[allow(clippy::needless_borrows_for_generic_args)]
3253 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3254 }
3255 struct_ser.end()
3256 }
3257}
3258impl<'de> serde::Deserialize<'de> for FlatIndex {
3259 #[allow(deprecated)]
3260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3261 where
3262 D: serde::Deserializer<'de>,
3263 {
3264 const FIELDS: &[&str] = &[
3265 "config",
3266 "vector_files",
3267 "vectorFiles",
3268 "next_vector_id",
3269 "nextVectorId",
3270 ];
3271
3272 #[allow(clippy::enum_variant_names)]
3273 enum GeneratedField {
3274 Config,
3275 VectorFiles,
3276 NextVectorId,
3277 }
3278 impl<'de> serde::Deserialize<'de> for GeneratedField {
3279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3280 where
3281 D: serde::Deserializer<'de>,
3282 {
3283 struct GeneratedVisitor;
3284
3285 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3286 type Value = GeneratedField;
3287
3288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3289 write!(formatter, "expected one of: {:?}", &FIELDS)
3290 }
3291
3292 #[allow(unused_variables)]
3293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3294 where
3295 E: serde::de::Error,
3296 {
3297 match value {
3298 "config" => Ok(GeneratedField::Config),
3299 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3300 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3301 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3302 }
3303 }
3304 }
3305 deserializer.deserialize_identifier(GeneratedVisitor)
3306 }
3307 }
3308 struct GeneratedVisitor;
3309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3310 type Value = FlatIndex;
3311
3312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3313 formatter.write_str("struct hummock.FlatIndex")
3314 }
3315
3316 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3317 where
3318 V: serde::de::MapAccess<'de>,
3319 {
3320 let mut config__ = None;
3321 let mut vector_files__ = None;
3322 let mut next_vector_id__ = None;
3323 while let Some(k) = map_.next_key()? {
3324 match k {
3325 GeneratedField::Config => {
3326 if config__.is_some() {
3327 return Err(serde::de::Error::duplicate_field("config"));
3328 }
3329 config__ = map_.next_value()?;
3330 }
3331 GeneratedField::VectorFiles => {
3332 if vector_files__.is_some() {
3333 return Err(serde::de::Error::duplicate_field("vectorFiles"));
3334 }
3335 vector_files__ = Some(map_.next_value()?);
3336 }
3337 GeneratedField::NextVectorId => {
3338 if next_vector_id__.is_some() {
3339 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3340 }
3341 next_vector_id__ =
3342 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3343 ;
3344 }
3345 }
3346 }
3347 Ok(FlatIndex {
3348 config: config__,
3349 vector_files: vector_files__.unwrap_or_default(),
3350 next_vector_id: next_vector_id__.unwrap_or_default(),
3351 })
3352 }
3353 }
3354 deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3355 }
3356}
3357impl serde::Serialize for FlatIndexAdd {
3358 #[allow(deprecated)]
3359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3360 where
3361 S: serde::Serializer,
3362 {
3363 use serde::ser::SerializeStruct;
3364 let mut len = 0;
3365 if !self.added_vector_files.is_empty() {
3366 len += 1;
3367 }
3368 if self.next_vector_id != 0 {
3369 len += 1;
3370 }
3371 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3372 if !self.added_vector_files.is_empty() {
3373 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3374 }
3375 if self.next_vector_id != 0 {
3376 #[allow(clippy::needless_borrow)]
3377 #[allow(clippy::needless_borrows_for_generic_args)]
3378 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3379 }
3380 struct_ser.end()
3381 }
3382}
3383impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3384 #[allow(deprecated)]
3385 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3386 where
3387 D: serde::Deserializer<'de>,
3388 {
3389 const FIELDS: &[&str] = &[
3390 "added_vector_files",
3391 "addedVectorFiles",
3392 "next_vector_id",
3393 "nextVectorId",
3394 ];
3395
3396 #[allow(clippy::enum_variant_names)]
3397 enum GeneratedField {
3398 AddedVectorFiles,
3399 NextVectorId,
3400 }
3401 impl<'de> serde::Deserialize<'de> for GeneratedField {
3402 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3403 where
3404 D: serde::Deserializer<'de>,
3405 {
3406 struct GeneratedVisitor;
3407
3408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3409 type Value = GeneratedField;
3410
3411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3412 write!(formatter, "expected one of: {:?}", &FIELDS)
3413 }
3414
3415 #[allow(unused_variables)]
3416 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3417 where
3418 E: serde::de::Error,
3419 {
3420 match value {
3421 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3422 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3423 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3424 }
3425 }
3426 }
3427 deserializer.deserialize_identifier(GeneratedVisitor)
3428 }
3429 }
3430 struct GeneratedVisitor;
3431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3432 type Value = FlatIndexAdd;
3433
3434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3435 formatter.write_str("struct hummock.FlatIndexAdd")
3436 }
3437
3438 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3439 where
3440 V: serde::de::MapAccess<'de>,
3441 {
3442 let mut added_vector_files__ = None;
3443 let mut next_vector_id__ = None;
3444 while let Some(k) = map_.next_key()? {
3445 match k {
3446 GeneratedField::AddedVectorFiles => {
3447 if added_vector_files__.is_some() {
3448 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3449 }
3450 added_vector_files__ = Some(map_.next_value()?);
3451 }
3452 GeneratedField::NextVectorId => {
3453 if next_vector_id__.is_some() {
3454 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3455 }
3456 next_vector_id__ =
3457 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3458 ;
3459 }
3460 }
3461 }
3462 Ok(FlatIndexAdd {
3463 added_vector_files: added_vector_files__.unwrap_or_default(),
3464 next_vector_id: next_vector_id__.unwrap_or_default(),
3465 })
3466 }
3467 }
3468 deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3469 }
3470}
3471impl serde::Serialize for FullScanTask {
3472 #[allow(deprecated)]
3473 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3474 where
3475 S: serde::Serializer,
3476 {
3477 use serde::ser::SerializeStruct;
3478 let mut len = 0;
3479 if self.sst_retention_watermark != 0 {
3480 len += 1;
3481 }
3482 if self.prefix.is_some() {
3483 len += 1;
3484 }
3485 if self.start_after.is_some() {
3486 len += 1;
3487 }
3488 if self.limit.is_some() {
3489 len += 1;
3490 }
3491 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3492 if self.sst_retention_watermark != 0 {
3493 #[allow(clippy::needless_borrow)]
3494 #[allow(clippy::needless_borrows_for_generic_args)]
3495 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3496 }
3497 if let Some(v) = self.prefix.as_ref() {
3498 struct_ser.serialize_field("prefix", v)?;
3499 }
3500 if let Some(v) = self.start_after.as_ref() {
3501 struct_ser.serialize_field("startAfter", v)?;
3502 }
3503 if let Some(v) = self.limit.as_ref() {
3504 #[allow(clippy::needless_borrow)]
3505 #[allow(clippy::needless_borrows_for_generic_args)]
3506 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3507 }
3508 struct_ser.end()
3509 }
3510}
3511impl<'de> serde::Deserialize<'de> for FullScanTask {
3512 #[allow(deprecated)]
3513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3514 where
3515 D: serde::Deserializer<'de>,
3516 {
3517 const FIELDS: &[&str] = &[
3518 "sst_retention_watermark",
3519 "sstRetentionWatermark",
3520 "prefix",
3521 "start_after",
3522 "startAfter",
3523 "limit",
3524 ];
3525
3526 #[allow(clippy::enum_variant_names)]
3527 enum GeneratedField {
3528 SstRetentionWatermark,
3529 Prefix,
3530 StartAfter,
3531 Limit,
3532 }
3533 impl<'de> serde::Deserialize<'de> for GeneratedField {
3534 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3535 where
3536 D: serde::Deserializer<'de>,
3537 {
3538 struct GeneratedVisitor;
3539
3540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3541 type Value = GeneratedField;
3542
3543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3544 write!(formatter, "expected one of: {:?}", &FIELDS)
3545 }
3546
3547 #[allow(unused_variables)]
3548 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3549 where
3550 E: serde::de::Error,
3551 {
3552 match value {
3553 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3554 "prefix" => Ok(GeneratedField::Prefix),
3555 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3556 "limit" => Ok(GeneratedField::Limit),
3557 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3558 }
3559 }
3560 }
3561 deserializer.deserialize_identifier(GeneratedVisitor)
3562 }
3563 }
3564 struct GeneratedVisitor;
3565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3566 type Value = FullScanTask;
3567
3568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3569 formatter.write_str("struct hummock.FullScanTask")
3570 }
3571
3572 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3573 where
3574 V: serde::de::MapAccess<'de>,
3575 {
3576 let mut sst_retention_watermark__ = None;
3577 let mut prefix__ = None;
3578 let mut start_after__ = None;
3579 let mut limit__ = None;
3580 while let Some(k) = map_.next_key()? {
3581 match k {
3582 GeneratedField::SstRetentionWatermark => {
3583 if sst_retention_watermark__.is_some() {
3584 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3585 }
3586 sst_retention_watermark__ =
3587 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3588 ;
3589 }
3590 GeneratedField::Prefix => {
3591 if prefix__.is_some() {
3592 return Err(serde::de::Error::duplicate_field("prefix"));
3593 }
3594 prefix__ = map_.next_value()?;
3595 }
3596 GeneratedField::StartAfter => {
3597 if start_after__.is_some() {
3598 return Err(serde::de::Error::duplicate_field("startAfter"));
3599 }
3600 start_after__ = map_.next_value()?;
3601 }
3602 GeneratedField::Limit => {
3603 if limit__.is_some() {
3604 return Err(serde::de::Error::duplicate_field("limit"));
3605 }
3606 limit__ =
3607 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3608 ;
3609 }
3610 }
3611 }
3612 Ok(FullScanTask {
3613 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3614 prefix: prefix__,
3615 start_after: start_after__,
3616 limit: limit__,
3617 })
3618 }
3619 }
3620 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3621 }
3622}
3623impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3624 #[allow(deprecated)]
3625 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3626 where
3627 S: serde::Serializer,
3628 {
3629 use serde::ser::SerializeStruct;
3630 let len = 0;
3631 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3632 struct_ser.end()
3633 }
3634}
3635impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3636 #[allow(deprecated)]
3637 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3638 where
3639 D: serde::Deserializer<'de>,
3640 {
3641 const FIELDS: &[&str] = &[
3642 ];
3643
3644 #[allow(clippy::enum_variant_names)]
3645 enum GeneratedField {
3646 }
3647 impl<'de> serde::Deserialize<'de> for GeneratedField {
3648 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3649 where
3650 D: serde::Deserializer<'de>,
3651 {
3652 struct GeneratedVisitor;
3653
3654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3655 type Value = GeneratedField;
3656
3657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3658 write!(formatter, "expected one of: {:?}", &FIELDS)
3659 }
3660
3661 #[allow(unused_variables)]
3662 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3663 where
3664 E: serde::de::Error,
3665 {
3666 Err(serde::de::Error::unknown_field(value, FIELDS))
3667 }
3668 }
3669 deserializer.deserialize_identifier(GeneratedVisitor)
3670 }
3671 }
3672 struct GeneratedVisitor;
3673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3674 type Value = GetAssignedCompactTaskNumRequest;
3675
3676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3677 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3678 }
3679
3680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3681 where
3682 V: serde::de::MapAccess<'de>,
3683 {
3684 while map_.next_key::<GeneratedField>()?.is_some() {
3685 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3686 }
3687 Ok(GetAssignedCompactTaskNumRequest {
3688 })
3689 }
3690 }
3691 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3692 }
3693}
3694impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3695 #[allow(deprecated)]
3696 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3697 where
3698 S: serde::Serializer,
3699 {
3700 use serde::ser::SerializeStruct;
3701 let mut len = 0;
3702 if self.num_tasks != 0 {
3703 len += 1;
3704 }
3705 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3706 if self.num_tasks != 0 {
3707 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3708 }
3709 struct_ser.end()
3710 }
3711}
3712impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3713 #[allow(deprecated)]
3714 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3715 where
3716 D: serde::Deserializer<'de>,
3717 {
3718 const FIELDS: &[&str] = &[
3719 "num_tasks",
3720 "numTasks",
3721 ];
3722
3723 #[allow(clippy::enum_variant_names)]
3724 enum GeneratedField {
3725 NumTasks,
3726 }
3727 impl<'de> serde::Deserialize<'de> for GeneratedField {
3728 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3729 where
3730 D: serde::Deserializer<'de>,
3731 {
3732 struct GeneratedVisitor;
3733
3734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3735 type Value = GeneratedField;
3736
3737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3738 write!(formatter, "expected one of: {:?}", &FIELDS)
3739 }
3740
3741 #[allow(unused_variables)]
3742 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3743 where
3744 E: serde::de::Error,
3745 {
3746 match value {
3747 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3748 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3749 }
3750 }
3751 }
3752 deserializer.deserialize_identifier(GeneratedVisitor)
3753 }
3754 }
3755 struct GeneratedVisitor;
3756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3757 type Value = GetAssignedCompactTaskNumResponse;
3758
3759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3760 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3761 }
3762
3763 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3764 where
3765 V: serde::de::MapAccess<'de>,
3766 {
3767 let mut num_tasks__ = None;
3768 while let Some(k) = map_.next_key()? {
3769 match k {
3770 GeneratedField::NumTasks => {
3771 if num_tasks__.is_some() {
3772 return Err(serde::de::Error::duplicate_field("numTasks"));
3773 }
3774 num_tasks__ =
3775 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3776 ;
3777 }
3778 }
3779 }
3780 Ok(GetAssignedCompactTaskNumResponse {
3781 num_tasks: num_tasks__.unwrap_or_default(),
3782 })
3783 }
3784 }
3785 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3786 }
3787}
3788impl serde::Serialize for GetCompactionScoreRequest {
3789 #[allow(deprecated)]
3790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3791 where
3792 S: serde::Serializer,
3793 {
3794 use serde::ser::SerializeStruct;
3795 let mut len = 0;
3796 if self.compaction_group_id != 0 {
3797 len += 1;
3798 }
3799 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3800 if self.compaction_group_id != 0 {
3801 #[allow(clippy::needless_borrow)]
3802 #[allow(clippy::needless_borrows_for_generic_args)]
3803 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3804 }
3805 struct_ser.end()
3806 }
3807}
3808impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3809 #[allow(deprecated)]
3810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3811 where
3812 D: serde::Deserializer<'de>,
3813 {
3814 const FIELDS: &[&str] = &[
3815 "compaction_group_id",
3816 "compactionGroupId",
3817 ];
3818
3819 #[allow(clippy::enum_variant_names)]
3820 enum GeneratedField {
3821 CompactionGroupId,
3822 }
3823 impl<'de> serde::Deserialize<'de> for GeneratedField {
3824 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3825 where
3826 D: serde::Deserializer<'de>,
3827 {
3828 struct GeneratedVisitor;
3829
3830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3831 type Value = GeneratedField;
3832
3833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3834 write!(formatter, "expected one of: {:?}", &FIELDS)
3835 }
3836
3837 #[allow(unused_variables)]
3838 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3839 where
3840 E: serde::de::Error,
3841 {
3842 match value {
3843 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3844 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3845 }
3846 }
3847 }
3848 deserializer.deserialize_identifier(GeneratedVisitor)
3849 }
3850 }
3851 struct GeneratedVisitor;
3852 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3853 type Value = GetCompactionScoreRequest;
3854
3855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3856 formatter.write_str("struct hummock.GetCompactionScoreRequest")
3857 }
3858
3859 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3860 where
3861 V: serde::de::MapAccess<'de>,
3862 {
3863 let mut compaction_group_id__ = None;
3864 while let Some(k) = map_.next_key()? {
3865 match k {
3866 GeneratedField::CompactionGroupId => {
3867 if compaction_group_id__.is_some() {
3868 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3869 }
3870 compaction_group_id__ =
3871 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3872 ;
3873 }
3874 }
3875 }
3876 Ok(GetCompactionScoreRequest {
3877 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3878 })
3879 }
3880 }
3881 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
3882 }
3883}
3884impl serde::Serialize for GetCompactionScoreResponse {
3885 #[allow(deprecated)]
3886 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3887 where
3888 S: serde::Serializer,
3889 {
3890 use serde::ser::SerializeStruct;
3891 let mut len = 0;
3892 if self.compaction_group_id != 0 {
3893 len += 1;
3894 }
3895 if !self.scores.is_empty() {
3896 len += 1;
3897 }
3898 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
3899 if self.compaction_group_id != 0 {
3900 #[allow(clippy::needless_borrow)]
3901 #[allow(clippy::needless_borrows_for_generic_args)]
3902 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3903 }
3904 if !self.scores.is_empty() {
3905 struct_ser.serialize_field("scores", &self.scores)?;
3906 }
3907 struct_ser.end()
3908 }
3909}
3910impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
3911 #[allow(deprecated)]
3912 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3913 where
3914 D: serde::Deserializer<'de>,
3915 {
3916 const FIELDS: &[&str] = &[
3917 "compaction_group_id",
3918 "compactionGroupId",
3919 "scores",
3920 ];
3921
3922 #[allow(clippy::enum_variant_names)]
3923 enum GeneratedField {
3924 CompactionGroupId,
3925 Scores,
3926 }
3927 impl<'de> serde::Deserialize<'de> for GeneratedField {
3928 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3929 where
3930 D: serde::Deserializer<'de>,
3931 {
3932 struct GeneratedVisitor;
3933
3934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3935 type Value = GeneratedField;
3936
3937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3938 write!(formatter, "expected one of: {:?}", &FIELDS)
3939 }
3940
3941 #[allow(unused_variables)]
3942 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3943 where
3944 E: serde::de::Error,
3945 {
3946 match value {
3947 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3948 "scores" => Ok(GeneratedField::Scores),
3949 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3950 }
3951 }
3952 }
3953 deserializer.deserialize_identifier(GeneratedVisitor)
3954 }
3955 }
3956 struct GeneratedVisitor;
3957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3958 type Value = GetCompactionScoreResponse;
3959
3960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3961 formatter.write_str("struct hummock.GetCompactionScoreResponse")
3962 }
3963
3964 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
3965 where
3966 V: serde::de::MapAccess<'de>,
3967 {
3968 let mut compaction_group_id__ = None;
3969 let mut scores__ = None;
3970 while let Some(k) = map_.next_key()? {
3971 match k {
3972 GeneratedField::CompactionGroupId => {
3973 if compaction_group_id__.is_some() {
3974 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3975 }
3976 compaction_group_id__ =
3977 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3978 ;
3979 }
3980 GeneratedField::Scores => {
3981 if scores__.is_some() {
3982 return Err(serde::de::Error::duplicate_field("scores"));
3983 }
3984 scores__ = Some(map_.next_value()?);
3985 }
3986 }
3987 }
3988 Ok(GetCompactionScoreResponse {
3989 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3990 scores: scores__.unwrap_or_default(),
3991 })
3992 }
3993 }
3994 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
3995 }
3996}
3997impl serde::Serialize for get_compaction_score_response::PickerInfo {
3998 #[allow(deprecated)]
3999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4000 where
4001 S: serde::Serializer,
4002 {
4003 use serde::ser::SerializeStruct;
4004 let mut len = 0;
4005 if self.score != 0 {
4006 len += 1;
4007 }
4008 if self.select_level != 0 {
4009 len += 1;
4010 }
4011 if self.target_level != 0 {
4012 len += 1;
4013 }
4014 if !self.picker_type.is_empty() {
4015 len += 1;
4016 }
4017 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
4018 if self.score != 0 {
4019 #[allow(clippy::needless_borrow)]
4020 #[allow(clippy::needless_borrows_for_generic_args)]
4021 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
4022 }
4023 if self.select_level != 0 {
4024 #[allow(clippy::needless_borrow)]
4025 #[allow(clippy::needless_borrows_for_generic_args)]
4026 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
4027 }
4028 if self.target_level != 0 {
4029 #[allow(clippy::needless_borrow)]
4030 #[allow(clippy::needless_borrows_for_generic_args)]
4031 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
4032 }
4033 if !self.picker_type.is_empty() {
4034 struct_ser.serialize_field("pickerType", &self.picker_type)?;
4035 }
4036 struct_ser.end()
4037 }
4038}
4039impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
4040 #[allow(deprecated)]
4041 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4042 where
4043 D: serde::Deserializer<'de>,
4044 {
4045 const FIELDS: &[&str] = &[
4046 "score",
4047 "select_level",
4048 "selectLevel",
4049 "target_level",
4050 "targetLevel",
4051 "picker_type",
4052 "pickerType",
4053 ];
4054
4055 #[allow(clippy::enum_variant_names)]
4056 enum GeneratedField {
4057 Score,
4058 SelectLevel,
4059 TargetLevel,
4060 PickerType,
4061 }
4062 impl<'de> serde::Deserialize<'de> for GeneratedField {
4063 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4064 where
4065 D: serde::Deserializer<'de>,
4066 {
4067 struct GeneratedVisitor;
4068
4069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4070 type Value = GeneratedField;
4071
4072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4073 write!(formatter, "expected one of: {:?}", &FIELDS)
4074 }
4075
4076 #[allow(unused_variables)]
4077 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4078 where
4079 E: serde::de::Error,
4080 {
4081 match value {
4082 "score" => Ok(GeneratedField::Score),
4083 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4084 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4085 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4086 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4087 }
4088 }
4089 }
4090 deserializer.deserialize_identifier(GeneratedVisitor)
4091 }
4092 }
4093 struct GeneratedVisitor;
4094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4095 type Value = get_compaction_score_response::PickerInfo;
4096
4097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4098 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4099 }
4100
4101 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4102 where
4103 V: serde::de::MapAccess<'de>,
4104 {
4105 let mut score__ = None;
4106 let mut select_level__ = None;
4107 let mut target_level__ = None;
4108 let mut picker_type__ = None;
4109 while let Some(k) = map_.next_key()? {
4110 match k {
4111 GeneratedField::Score => {
4112 if score__.is_some() {
4113 return Err(serde::de::Error::duplicate_field("score"));
4114 }
4115 score__ =
4116 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4117 ;
4118 }
4119 GeneratedField::SelectLevel => {
4120 if select_level__.is_some() {
4121 return Err(serde::de::Error::duplicate_field("selectLevel"));
4122 }
4123 select_level__ =
4124 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4125 ;
4126 }
4127 GeneratedField::TargetLevel => {
4128 if target_level__.is_some() {
4129 return Err(serde::de::Error::duplicate_field("targetLevel"));
4130 }
4131 target_level__ =
4132 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4133 ;
4134 }
4135 GeneratedField::PickerType => {
4136 if picker_type__.is_some() {
4137 return Err(serde::de::Error::duplicate_field("pickerType"));
4138 }
4139 picker_type__ = Some(map_.next_value()?);
4140 }
4141 }
4142 }
4143 Ok(get_compaction_score_response::PickerInfo {
4144 score: score__.unwrap_or_default(),
4145 select_level: select_level__.unwrap_or_default(),
4146 target_level: target_level__.unwrap_or_default(),
4147 picker_type: picker_type__.unwrap_or_default(),
4148 })
4149 }
4150 }
4151 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4152 }
4153}
4154impl serde::Serialize for GetCurrentVersionRequest {
4155 #[allow(deprecated)]
4156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4157 where
4158 S: serde::Serializer,
4159 {
4160 use serde::ser::SerializeStruct;
4161 let len = 0;
4162 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4163 struct_ser.end()
4164 }
4165}
4166impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4167 #[allow(deprecated)]
4168 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4169 where
4170 D: serde::Deserializer<'de>,
4171 {
4172 const FIELDS: &[&str] = &[
4173 ];
4174
4175 #[allow(clippy::enum_variant_names)]
4176 enum GeneratedField {
4177 }
4178 impl<'de> serde::Deserialize<'de> for GeneratedField {
4179 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4180 where
4181 D: serde::Deserializer<'de>,
4182 {
4183 struct GeneratedVisitor;
4184
4185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4186 type Value = GeneratedField;
4187
4188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4189 write!(formatter, "expected one of: {:?}", &FIELDS)
4190 }
4191
4192 #[allow(unused_variables)]
4193 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4194 where
4195 E: serde::de::Error,
4196 {
4197 Err(serde::de::Error::unknown_field(value, FIELDS))
4198 }
4199 }
4200 deserializer.deserialize_identifier(GeneratedVisitor)
4201 }
4202 }
4203 struct GeneratedVisitor;
4204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4205 type Value = GetCurrentVersionRequest;
4206
4207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4208 formatter.write_str("struct hummock.GetCurrentVersionRequest")
4209 }
4210
4211 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4212 where
4213 V: serde::de::MapAccess<'de>,
4214 {
4215 while map_.next_key::<GeneratedField>()?.is_some() {
4216 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4217 }
4218 Ok(GetCurrentVersionRequest {
4219 })
4220 }
4221 }
4222 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4223 }
4224}
4225impl serde::Serialize for GetCurrentVersionResponse {
4226 #[allow(deprecated)]
4227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4228 where
4229 S: serde::Serializer,
4230 {
4231 use serde::ser::SerializeStruct;
4232 let mut len = 0;
4233 if self.status.is_some() {
4234 len += 1;
4235 }
4236 if self.current_version.is_some() {
4237 len += 1;
4238 }
4239 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4240 if let Some(v) = self.status.as_ref() {
4241 struct_ser.serialize_field("status", v)?;
4242 }
4243 if let Some(v) = self.current_version.as_ref() {
4244 struct_ser.serialize_field("currentVersion", v)?;
4245 }
4246 struct_ser.end()
4247 }
4248}
4249impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4250 #[allow(deprecated)]
4251 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4252 where
4253 D: serde::Deserializer<'de>,
4254 {
4255 const FIELDS: &[&str] = &[
4256 "status",
4257 "current_version",
4258 "currentVersion",
4259 ];
4260
4261 #[allow(clippy::enum_variant_names)]
4262 enum GeneratedField {
4263 Status,
4264 CurrentVersion,
4265 }
4266 impl<'de> serde::Deserialize<'de> for GeneratedField {
4267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4268 where
4269 D: serde::Deserializer<'de>,
4270 {
4271 struct GeneratedVisitor;
4272
4273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4274 type Value = GeneratedField;
4275
4276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4277 write!(formatter, "expected one of: {:?}", &FIELDS)
4278 }
4279
4280 #[allow(unused_variables)]
4281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4282 where
4283 E: serde::de::Error,
4284 {
4285 match value {
4286 "status" => Ok(GeneratedField::Status),
4287 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4289 }
4290 }
4291 }
4292 deserializer.deserialize_identifier(GeneratedVisitor)
4293 }
4294 }
4295 struct GeneratedVisitor;
4296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4297 type Value = GetCurrentVersionResponse;
4298
4299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4300 formatter.write_str("struct hummock.GetCurrentVersionResponse")
4301 }
4302
4303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4304 where
4305 V: serde::de::MapAccess<'de>,
4306 {
4307 let mut status__ = None;
4308 let mut current_version__ = None;
4309 while let Some(k) = map_.next_key()? {
4310 match k {
4311 GeneratedField::Status => {
4312 if status__.is_some() {
4313 return Err(serde::de::Error::duplicate_field("status"));
4314 }
4315 status__ = map_.next_value()?;
4316 }
4317 GeneratedField::CurrentVersion => {
4318 if current_version__.is_some() {
4319 return Err(serde::de::Error::duplicate_field("currentVersion"));
4320 }
4321 current_version__ = map_.next_value()?;
4322 }
4323 }
4324 }
4325 Ok(GetCurrentVersionResponse {
4326 status: status__,
4327 current_version: current_version__,
4328 })
4329 }
4330 }
4331 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4332 }
4333}
4334impl serde::Serialize for GetNewObjectIdsRequest {
4335 #[allow(deprecated)]
4336 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4337 where
4338 S: serde::Serializer,
4339 {
4340 use serde::ser::SerializeStruct;
4341 let mut len = 0;
4342 if self.number != 0 {
4343 len += 1;
4344 }
4345 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4346 if self.number != 0 {
4347 struct_ser.serialize_field("number", &self.number)?;
4348 }
4349 struct_ser.end()
4350 }
4351}
4352impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4353 #[allow(deprecated)]
4354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4355 where
4356 D: serde::Deserializer<'de>,
4357 {
4358 const FIELDS: &[&str] = &[
4359 "number",
4360 ];
4361
4362 #[allow(clippy::enum_variant_names)]
4363 enum GeneratedField {
4364 Number,
4365 }
4366 impl<'de> serde::Deserialize<'de> for GeneratedField {
4367 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4368 where
4369 D: serde::Deserializer<'de>,
4370 {
4371 struct GeneratedVisitor;
4372
4373 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4374 type Value = GeneratedField;
4375
4376 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4377 write!(formatter, "expected one of: {:?}", &FIELDS)
4378 }
4379
4380 #[allow(unused_variables)]
4381 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4382 where
4383 E: serde::de::Error,
4384 {
4385 match value {
4386 "number" => Ok(GeneratedField::Number),
4387 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4388 }
4389 }
4390 }
4391 deserializer.deserialize_identifier(GeneratedVisitor)
4392 }
4393 }
4394 struct GeneratedVisitor;
4395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4396 type Value = GetNewObjectIdsRequest;
4397
4398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4399 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4400 }
4401
4402 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4403 where
4404 V: serde::de::MapAccess<'de>,
4405 {
4406 let mut number__ = None;
4407 while let Some(k) = map_.next_key()? {
4408 match k {
4409 GeneratedField::Number => {
4410 if number__.is_some() {
4411 return Err(serde::de::Error::duplicate_field("number"));
4412 }
4413 number__ =
4414 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4415 ;
4416 }
4417 }
4418 }
4419 Ok(GetNewObjectIdsRequest {
4420 number: number__.unwrap_or_default(),
4421 })
4422 }
4423 }
4424 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4425 }
4426}
4427impl serde::Serialize for GetNewObjectIdsResponse {
4428 #[allow(deprecated)]
4429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4430 where
4431 S: serde::Serializer,
4432 {
4433 use serde::ser::SerializeStruct;
4434 let mut len = 0;
4435 if self.status.is_some() {
4436 len += 1;
4437 }
4438 if self.start_id != 0 {
4439 len += 1;
4440 }
4441 if self.end_id != 0 {
4442 len += 1;
4443 }
4444 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4445 if let Some(v) = self.status.as_ref() {
4446 struct_ser.serialize_field("status", v)?;
4447 }
4448 if self.start_id != 0 {
4449 #[allow(clippy::needless_borrow)]
4450 #[allow(clippy::needless_borrows_for_generic_args)]
4451 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4452 }
4453 if self.end_id != 0 {
4454 #[allow(clippy::needless_borrow)]
4455 #[allow(clippy::needless_borrows_for_generic_args)]
4456 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4457 }
4458 struct_ser.end()
4459 }
4460}
4461impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4462 #[allow(deprecated)]
4463 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4464 where
4465 D: serde::Deserializer<'de>,
4466 {
4467 const FIELDS: &[&str] = &[
4468 "status",
4469 "start_id",
4470 "startId",
4471 "end_id",
4472 "endId",
4473 ];
4474
4475 #[allow(clippy::enum_variant_names)]
4476 enum GeneratedField {
4477 Status,
4478 StartId,
4479 EndId,
4480 }
4481 impl<'de> serde::Deserialize<'de> for GeneratedField {
4482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4483 where
4484 D: serde::Deserializer<'de>,
4485 {
4486 struct GeneratedVisitor;
4487
4488 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4489 type Value = GeneratedField;
4490
4491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4492 write!(formatter, "expected one of: {:?}", &FIELDS)
4493 }
4494
4495 #[allow(unused_variables)]
4496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4497 where
4498 E: serde::de::Error,
4499 {
4500 match value {
4501 "status" => Ok(GeneratedField::Status),
4502 "startId" | "start_id" => Ok(GeneratedField::StartId),
4503 "endId" | "end_id" => Ok(GeneratedField::EndId),
4504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4505 }
4506 }
4507 }
4508 deserializer.deserialize_identifier(GeneratedVisitor)
4509 }
4510 }
4511 struct GeneratedVisitor;
4512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4513 type Value = GetNewObjectIdsResponse;
4514
4515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4516 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4517 }
4518
4519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4520 where
4521 V: serde::de::MapAccess<'de>,
4522 {
4523 let mut status__ = None;
4524 let mut start_id__ = None;
4525 let mut end_id__ = None;
4526 while let Some(k) = map_.next_key()? {
4527 match k {
4528 GeneratedField::Status => {
4529 if status__.is_some() {
4530 return Err(serde::de::Error::duplicate_field("status"));
4531 }
4532 status__ = map_.next_value()?;
4533 }
4534 GeneratedField::StartId => {
4535 if start_id__.is_some() {
4536 return Err(serde::de::Error::duplicate_field("startId"));
4537 }
4538 start_id__ =
4539 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4540 ;
4541 }
4542 GeneratedField::EndId => {
4543 if end_id__.is_some() {
4544 return Err(serde::de::Error::duplicate_field("endId"));
4545 }
4546 end_id__ =
4547 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4548 ;
4549 }
4550 }
4551 }
4552 Ok(GetNewObjectIdsResponse {
4553 status: status__,
4554 start_id: start_id__.unwrap_or_default(),
4555 end_id: end_id__.unwrap_or_default(),
4556 })
4557 }
4558 }
4559 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4560 }
4561}
4562impl serde::Serialize for GetVersionByEpochRequest {
4563 #[allow(deprecated)]
4564 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4565 where
4566 S: serde::Serializer,
4567 {
4568 use serde::ser::SerializeStruct;
4569 let mut len = 0;
4570 if self.epoch != 0 {
4571 len += 1;
4572 }
4573 if self.table_id != 0 {
4574 len += 1;
4575 }
4576 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
4577 if self.epoch != 0 {
4578 #[allow(clippy::needless_borrow)]
4579 #[allow(clippy::needless_borrows_for_generic_args)]
4580 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
4581 }
4582 if self.table_id != 0 {
4583 struct_ser.serialize_field("tableId", &self.table_id)?;
4584 }
4585 struct_ser.end()
4586 }
4587}
4588impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
4589 #[allow(deprecated)]
4590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4591 where
4592 D: serde::Deserializer<'de>,
4593 {
4594 const FIELDS: &[&str] = &[
4595 "epoch",
4596 "table_id",
4597 "tableId",
4598 ];
4599
4600 #[allow(clippy::enum_variant_names)]
4601 enum GeneratedField {
4602 Epoch,
4603 TableId,
4604 }
4605 impl<'de> serde::Deserialize<'de> for GeneratedField {
4606 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4607 where
4608 D: serde::Deserializer<'de>,
4609 {
4610 struct GeneratedVisitor;
4611
4612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4613 type Value = GeneratedField;
4614
4615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4616 write!(formatter, "expected one of: {:?}", &FIELDS)
4617 }
4618
4619 #[allow(unused_variables)]
4620 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4621 where
4622 E: serde::de::Error,
4623 {
4624 match value {
4625 "epoch" => Ok(GeneratedField::Epoch),
4626 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4627 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4628 }
4629 }
4630 }
4631 deserializer.deserialize_identifier(GeneratedVisitor)
4632 }
4633 }
4634 struct GeneratedVisitor;
4635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4636 type Value = GetVersionByEpochRequest;
4637
4638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4639 formatter.write_str("struct hummock.GetVersionByEpochRequest")
4640 }
4641
4642 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
4643 where
4644 V: serde::de::MapAccess<'de>,
4645 {
4646 let mut epoch__ = None;
4647 let mut table_id__ = None;
4648 while let Some(k) = map_.next_key()? {
4649 match k {
4650 GeneratedField::Epoch => {
4651 if epoch__.is_some() {
4652 return Err(serde::de::Error::duplicate_field("epoch"));
4653 }
4654 epoch__ =
4655 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4656 ;
4657 }
4658 GeneratedField::TableId => {
4659 if table_id__.is_some() {
4660 return Err(serde::de::Error::duplicate_field("tableId"));
4661 }
4662 table_id__ =
4663 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4664 ;
4665 }
4666 }
4667 }
4668 Ok(GetVersionByEpochRequest {
4669 epoch: epoch__.unwrap_or_default(),
4670 table_id: table_id__.unwrap_or_default(),
4671 })
4672 }
4673 }
4674 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
4675 }
4676}
4677impl serde::Serialize for GetVersionByEpochResponse {
4678 #[allow(deprecated)]
4679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4680 where
4681 S: serde::Serializer,
4682 {
4683 use serde::ser::SerializeStruct;
4684 let mut len = 0;
4685 if self.version.is_some() {
4686 len += 1;
4687 }
4688 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
4689 if let Some(v) = self.version.as_ref() {
4690 struct_ser.serialize_field("version", v)?;
4691 }
4692 struct_ser.end()
4693 }
4694}
4695impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
4696 #[allow(deprecated)]
4697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4698 where
4699 D: serde::Deserializer<'de>,
4700 {
4701 const FIELDS: &[&str] = &[
4702 "version",
4703 ];
4704
4705 #[allow(clippy::enum_variant_names)]
4706 enum GeneratedField {
4707 Version,
4708 }
4709 impl<'de> serde::Deserialize<'de> for GeneratedField {
4710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4711 where
4712 D: serde::Deserializer<'de>,
4713 {
4714 struct GeneratedVisitor;
4715
4716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4717 type Value = GeneratedField;
4718
4719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4720 write!(formatter, "expected one of: {:?}", &FIELDS)
4721 }
4722
4723 #[allow(unused_variables)]
4724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4725 where
4726 E: serde::de::Error,
4727 {
4728 match value {
4729 "version" => Ok(GeneratedField::Version),
4730 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4731 }
4732 }
4733 }
4734 deserializer.deserialize_identifier(GeneratedVisitor)
4735 }
4736 }
4737 struct GeneratedVisitor;
4738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4739 type Value = GetVersionByEpochResponse;
4740
4741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4742 formatter.write_str("struct hummock.GetVersionByEpochResponse")
4743 }
4744
4745 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
4746 where
4747 V: serde::de::MapAccess<'de>,
4748 {
4749 let mut version__ = None;
4750 while let Some(k) = map_.next_key()? {
4751 match k {
4752 GeneratedField::Version => {
4753 if version__.is_some() {
4754 return Err(serde::de::Error::duplicate_field("version"));
4755 }
4756 version__ = map_.next_value()?;
4757 }
4758 }
4759 }
4760 Ok(GetVersionByEpochResponse {
4761 version: version__,
4762 })
4763 }
4764 }
4765 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
4766 }
4767}
4768impl serde::Serialize for GroupConstruct {
4769 #[allow(deprecated)]
4770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4771 where
4772 S: serde::Serializer,
4773 {
4774 use serde::ser::SerializeStruct;
4775 let mut len = 0;
4776 if self.group_config.is_some() {
4777 len += 1;
4778 }
4779 if self.parent_group_id != 0 {
4780 len += 1;
4781 }
4782 if !self.table_ids.is_empty() {
4783 len += 1;
4784 }
4785 if self.group_id != 0 {
4786 len += 1;
4787 }
4788 if self.new_sst_start_id != 0 {
4789 len += 1;
4790 }
4791 if self.version != 0 {
4792 len += 1;
4793 }
4794 if self.split_key.is_some() {
4795 len += 1;
4796 }
4797 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
4798 if let Some(v) = self.group_config.as_ref() {
4799 struct_ser.serialize_field("groupConfig", v)?;
4800 }
4801 if self.parent_group_id != 0 {
4802 #[allow(clippy::needless_borrow)]
4803 #[allow(clippy::needless_borrows_for_generic_args)]
4804 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
4805 }
4806 if !self.table_ids.is_empty() {
4807 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4808 }
4809 if self.group_id != 0 {
4810 #[allow(clippy::needless_borrow)]
4811 #[allow(clippy::needless_borrows_for_generic_args)]
4812 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
4813 }
4814 if self.new_sst_start_id != 0 {
4815 #[allow(clippy::needless_borrow)]
4816 #[allow(clippy::needless_borrows_for_generic_args)]
4817 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
4818 }
4819 if self.version != 0 {
4820 let v = CompatibilityVersion::try_from(self.version)
4821 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4822 struct_ser.serialize_field("version", &v)?;
4823 }
4824 if let Some(v) = self.split_key.as_ref() {
4825 #[allow(clippy::needless_borrow)]
4826 #[allow(clippy::needless_borrows_for_generic_args)]
4827 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
4828 }
4829 struct_ser.end()
4830 }
4831}
4832impl<'de> serde::Deserialize<'de> for GroupConstruct {
4833 #[allow(deprecated)]
4834 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4835 where
4836 D: serde::Deserializer<'de>,
4837 {
4838 const FIELDS: &[&str] = &[
4839 "group_config",
4840 "groupConfig",
4841 "parent_group_id",
4842 "parentGroupId",
4843 "table_ids",
4844 "tableIds",
4845 "group_id",
4846 "groupId",
4847 "new_sst_start_id",
4848 "newSstStartId",
4849 "version",
4850 "split_key",
4851 "splitKey",
4852 ];
4853
4854 #[allow(clippy::enum_variant_names)]
4855 enum GeneratedField {
4856 GroupConfig,
4857 ParentGroupId,
4858 TableIds,
4859 GroupId,
4860 NewSstStartId,
4861 Version,
4862 SplitKey,
4863 }
4864 impl<'de> serde::Deserialize<'de> for GeneratedField {
4865 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4866 where
4867 D: serde::Deserializer<'de>,
4868 {
4869 struct GeneratedVisitor;
4870
4871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4872 type Value = GeneratedField;
4873
4874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4875 write!(formatter, "expected one of: {:?}", &FIELDS)
4876 }
4877
4878 #[allow(unused_variables)]
4879 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4880 where
4881 E: serde::de::Error,
4882 {
4883 match value {
4884 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
4885 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
4886 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4887 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
4888 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
4889 "version" => Ok(GeneratedField::Version),
4890 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
4891 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4892 }
4893 }
4894 }
4895 deserializer.deserialize_identifier(GeneratedVisitor)
4896 }
4897 }
4898 struct GeneratedVisitor;
4899 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4900 type Value = GroupConstruct;
4901
4902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4903 formatter.write_str("struct hummock.GroupConstruct")
4904 }
4905
4906 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
4907 where
4908 V: serde::de::MapAccess<'de>,
4909 {
4910 let mut group_config__ = None;
4911 let mut parent_group_id__ = None;
4912 let mut table_ids__ = None;
4913 let mut group_id__ = None;
4914 let mut new_sst_start_id__ = None;
4915 let mut version__ = None;
4916 let mut split_key__ = None;
4917 while let Some(k) = map_.next_key()? {
4918 match k {
4919 GeneratedField::GroupConfig => {
4920 if group_config__.is_some() {
4921 return Err(serde::de::Error::duplicate_field("groupConfig"));
4922 }
4923 group_config__ = map_.next_value()?;
4924 }
4925 GeneratedField::ParentGroupId => {
4926 if parent_group_id__.is_some() {
4927 return Err(serde::de::Error::duplicate_field("parentGroupId"));
4928 }
4929 parent_group_id__ =
4930 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4931 ;
4932 }
4933 GeneratedField::TableIds => {
4934 if table_ids__.is_some() {
4935 return Err(serde::de::Error::duplicate_field("tableIds"));
4936 }
4937 table_ids__ =
4938 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4939 .into_iter().map(|x| x.0).collect())
4940 ;
4941 }
4942 GeneratedField::GroupId => {
4943 if group_id__.is_some() {
4944 return Err(serde::de::Error::duplicate_field("groupId"));
4945 }
4946 group_id__ =
4947 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4948 ;
4949 }
4950 GeneratedField::NewSstStartId => {
4951 if new_sst_start_id__.is_some() {
4952 return Err(serde::de::Error::duplicate_field("newSstStartId"));
4953 }
4954 new_sst_start_id__ =
4955 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4956 ;
4957 }
4958 GeneratedField::Version => {
4959 if version__.is_some() {
4960 return Err(serde::de::Error::duplicate_field("version"));
4961 }
4962 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
4963 }
4964 GeneratedField::SplitKey => {
4965 if split_key__.is_some() {
4966 return Err(serde::de::Error::duplicate_field("splitKey"));
4967 }
4968 split_key__ =
4969 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
4970 ;
4971 }
4972 }
4973 }
4974 Ok(GroupConstruct {
4975 group_config: group_config__,
4976 parent_group_id: parent_group_id__.unwrap_or_default(),
4977 table_ids: table_ids__.unwrap_or_default(),
4978 group_id: group_id__.unwrap_or_default(),
4979 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
4980 version: version__.unwrap_or_default(),
4981 split_key: split_key__,
4982 })
4983 }
4984 }
4985 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
4986 }
4987}
4988impl serde::Serialize for GroupDelta {
4989 #[allow(deprecated)]
4990 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4991 where
4992 S: serde::Serializer,
4993 {
4994 use serde::ser::SerializeStruct;
4995 let mut len = 0;
4996 if self.delta_type.is_some() {
4997 len += 1;
4998 }
4999 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
5000 if let Some(v) = self.delta_type.as_ref() {
5001 match v {
5002 group_delta::DeltaType::IntraLevel(v) => {
5003 struct_ser.serialize_field("intraLevel", v)?;
5004 }
5005 group_delta::DeltaType::GroupConstruct(v) => {
5006 struct_ser.serialize_field("groupConstruct", v)?;
5007 }
5008 group_delta::DeltaType::GroupDestroy(v) => {
5009 struct_ser.serialize_field("groupDestroy", v)?;
5010 }
5011 group_delta::DeltaType::GroupMerge(v) => {
5012 struct_ser.serialize_field("groupMerge", v)?;
5013 }
5014 group_delta::DeltaType::NewL0SubLevel(v) => {
5015 struct_ser.serialize_field("newL0SubLevel", v)?;
5016 }
5017 group_delta::DeltaType::TruncateTables(v) => {
5018 struct_ser.serialize_field("truncateTables", v)?;
5019 }
5020 }
5021 }
5022 struct_ser.end()
5023 }
5024}
5025impl<'de> serde::Deserialize<'de> for GroupDelta {
5026 #[allow(deprecated)]
5027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5028 where
5029 D: serde::Deserializer<'de>,
5030 {
5031 const FIELDS: &[&str] = &[
5032 "intra_level",
5033 "intraLevel",
5034 "group_construct",
5035 "groupConstruct",
5036 "group_destroy",
5037 "groupDestroy",
5038 "group_merge",
5039 "groupMerge",
5040 "new_l0_sub_level",
5041 "newL0SubLevel",
5042 "truncate_tables",
5043 "truncateTables",
5044 ];
5045
5046 #[allow(clippy::enum_variant_names)]
5047 enum GeneratedField {
5048 IntraLevel,
5049 GroupConstruct,
5050 GroupDestroy,
5051 GroupMerge,
5052 NewL0SubLevel,
5053 TruncateTables,
5054 }
5055 impl<'de> serde::Deserialize<'de> for GeneratedField {
5056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5057 where
5058 D: serde::Deserializer<'de>,
5059 {
5060 struct GeneratedVisitor;
5061
5062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5063 type Value = GeneratedField;
5064
5065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5066 write!(formatter, "expected one of: {:?}", &FIELDS)
5067 }
5068
5069 #[allow(unused_variables)]
5070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5071 where
5072 E: serde::de::Error,
5073 {
5074 match value {
5075 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5076 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5077 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5078 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5079 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5080 "truncateTables" | "truncate_tables" => Ok(GeneratedField::TruncateTables),
5081 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5082 }
5083 }
5084 }
5085 deserializer.deserialize_identifier(GeneratedVisitor)
5086 }
5087 }
5088 struct GeneratedVisitor;
5089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5090 type Value = GroupDelta;
5091
5092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5093 formatter.write_str("struct hummock.GroupDelta")
5094 }
5095
5096 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5097 where
5098 V: serde::de::MapAccess<'de>,
5099 {
5100 let mut delta_type__ = None;
5101 while let Some(k) = map_.next_key()? {
5102 match k {
5103 GeneratedField::IntraLevel => {
5104 if delta_type__.is_some() {
5105 return Err(serde::de::Error::duplicate_field("intraLevel"));
5106 }
5107 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5108;
5109 }
5110 GeneratedField::GroupConstruct => {
5111 if delta_type__.is_some() {
5112 return Err(serde::de::Error::duplicate_field("groupConstruct"));
5113 }
5114 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5115;
5116 }
5117 GeneratedField::GroupDestroy => {
5118 if delta_type__.is_some() {
5119 return Err(serde::de::Error::duplicate_field("groupDestroy"));
5120 }
5121 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5122;
5123 }
5124 GeneratedField::GroupMerge => {
5125 if delta_type__.is_some() {
5126 return Err(serde::de::Error::duplicate_field("groupMerge"));
5127 }
5128 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5129;
5130 }
5131 GeneratedField::NewL0SubLevel => {
5132 if delta_type__.is_some() {
5133 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5134 }
5135 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5136;
5137 }
5138 GeneratedField::TruncateTables => {
5139 if delta_type__.is_some() {
5140 return Err(serde::de::Error::duplicate_field("truncateTables"));
5141 }
5142 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::TruncateTables)
5143;
5144 }
5145 }
5146 }
5147 Ok(GroupDelta {
5148 delta_type: delta_type__,
5149 })
5150 }
5151 }
5152 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5153 }
5154}
5155impl serde::Serialize for GroupDestroy {
5156 #[allow(deprecated)]
5157 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5158 where
5159 S: serde::Serializer,
5160 {
5161 use serde::ser::SerializeStruct;
5162 let len = 0;
5163 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5164 struct_ser.end()
5165 }
5166}
5167impl<'de> serde::Deserialize<'de> for GroupDestroy {
5168 #[allow(deprecated)]
5169 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5170 where
5171 D: serde::Deserializer<'de>,
5172 {
5173 const FIELDS: &[&str] = &[
5174 ];
5175
5176 #[allow(clippy::enum_variant_names)]
5177 enum GeneratedField {
5178 }
5179 impl<'de> serde::Deserialize<'de> for GeneratedField {
5180 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5181 where
5182 D: serde::Deserializer<'de>,
5183 {
5184 struct GeneratedVisitor;
5185
5186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5187 type Value = GeneratedField;
5188
5189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5190 write!(formatter, "expected one of: {:?}", &FIELDS)
5191 }
5192
5193 #[allow(unused_variables)]
5194 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5195 where
5196 E: serde::de::Error,
5197 {
5198 Err(serde::de::Error::unknown_field(value, FIELDS))
5199 }
5200 }
5201 deserializer.deserialize_identifier(GeneratedVisitor)
5202 }
5203 }
5204 struct GeneratedVisitor;
5205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5206 type Value = GroupDestroy;
5207
5208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5209 formatter.write_str("struct hummock.GroupDestroy")
5210 }
5211
5212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5213 where
5214 V: serde::de::MapAccess<'de>,
5215 {
5216 while map_.next_key::<GeneratedField>()?.is_some() {
5217 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5218 }
5219 Ok(GroupDestroy {
5220 })
5221 }
5222 }
5223 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5224 }
5225}
5226impl serde::Serialize for GroupMerge {
5227 #[allow(deprecated)]
5228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5229 where
5230 S: serde::Serializer,
5231 {
5232 use serde::ser::SerializeStruct;
5233 let mut len = 0;
5234 if self.left_group_id != 0 {
5235 len += 1;
5236 }
5237 if self.right_group_id != 0 {
5238 len += 1;
5239 }
5240 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5241 if self.left_group_id != 0 {
5242 #[allow(clippy::needless_borrow)]
5243 #[allow(clippy::needless_borrows_for_generic_args)]
5244 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5245 }
5246 if self.right_group_id != 0 {
5247 #[allow(clippy::needless_borrow)]
5248 #[allow(clippy::needless_borrows_for_generic_args)]
5249 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5250 }
5251 struct_ser.end()
5252 }
5253}
5254impl<'de> serde::Deserialize<'de> for GroupMerge {
5255 #[allow(deprecated)]
5256 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5257 where
5258 D: serde::Deserializer<'de>,
5259 {
5260 const FIELDS: &[&str] = &[
5261 "left_group_id",
5262 "leftGroupId",
5263 "right_group_id",
5264 "rightGroupId",
5265 ];
5266
5267 #[allow(clippy::enum_variant_names)]
5268 enum GeneratedField {
5269 LeftGroupId,
5270 RightGroupId,
5271 }
5272 impl<'de> serde::Deserialize<'de> for GeneratedField {
5273 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5274 where
5275 D: serde::Deserializer<'de>,
5276 {
5277 struct GeneratedVisitor;
5278
5279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5280 type Value = GeneratedField;
5281
5282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5283 write!(formatter, "expected one of: {:?}", &FIELDS)
5284 }
5285
5286 #[allow(unused_variables)]
5287 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5288 where
5289 E: serde::de::Error,
5290 {
5291 match value {
5292 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5293 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5295 }
5296 }
5297 }
5298 deserializer.deserialize_identifier(GeneratedVisitor)
5299 }
5300 }
5301 struct GeneratedVisitor;
5302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5303 type Value = GroupMerge;
5304
5305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5306 formatter.write_str("struct hummock.GroupMerge")
5307 }
5308
5309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5310 where
5311 V: serde::de::MapAccess<'de>,
5312 {
5313 let mut left_group_id__ = None;
5314 let mut right_group_id__ = None;
5315 while let Some(k) = map_.next_key()? {
5316 match k {
5317 GeneratedField::LeftGroupId => {
5318 if left_group_id__.is_some() {
5319 return Err(serde::de::Error::duplicate_field("leftGroupId"));
5320 }
5321 left_group_id__ =
5322 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5323 ;
5324 }
5325 GeneratedField::RightGroupId => {
5326 if right_group_id__.is_some() {
5327 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5328 }
5329 right_group_id__ =
5330 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5331 ;
5332 }
5333 }
5334 }
5335 Ok(GroupMerge {
5336 left_group_id: left_group_id__.unwrap_or_default(),
5337 right_group_id: right_group_id__.unwrap_or_default(),
5338 })
5339 }
5340 }
5341 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5342 }
5343}
5344impl serde::Serialize for HnswFlatIndex {
5345 #[allow(deprecated)]
5346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5347 where
5348 S: serde::Serializer,
5349 {
5350 use serde::ser::SerializeStruct;
5351 let mut len = 0;
5352 if self.config.is_some() {
5353 len += 1;
5354 }
5355 if !self.vector_files.is_empty() {
5356 len += 1;
5357 }
5358 if self.next_vector_id != 0 {
5359 len += 1;
5360 }
5361 if self.graph_file.is_some() {
5362 len += 1;
5363 }
5364 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndex", len)?;
5365 if let Some(v) = self.config.as_ref() {
5366 struct_ser.serialize_field("config", v)?;
5367 }
5368 if !self.vector_files.is_empty() {
5369 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
5370 }
5371 if self.next_vector_id != 0 {
5372 #[allow(clippy::needless_borrow)]
5373 #[allow(clippy::needless_borrows_for_generic_args)]
5374 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5375 }
5376 if let Some(v) = self.graph_file.as_ref() {
5377 struct_ser.serialize_field("graphFile", v)?;
5378 }
5379 struct_ser.end()
5380 }
5381}
5382impl<'de> serde::Deserialize<'de> for HnswFlatIndex {
5383 #[allow(deprecated)]
5384 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5385 where
5386 D: serde::Deserializer<'de>,
5387 {
5388 const FIELDS: &[&str] = &[
5389 "config",
5390 "vector_files",
5391 "vectorFiles",
5392 "next_vector_id",
5393 "nextVectorId",
5394 "graph_file",
5395 "graphFile",
5396 ];
5397
5398 #[allow(clippy::enum_variant_names)]
5399 enum GeneratedField {
5400 Config,
5401 VectorFiles,
5402 NextVectorId,
5403 GraphFile,
5404 }
5405 impl<'de> serde::Deserialize<'de> for GeneratedField {
5406 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5407 where
5408 D: serde::Deserializer<'de>,
5409 {
5410 struct GeneratedVisitor;
5411
5412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5413 type Value = GeneratedField;
5414
5415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5416 write!(formatter, "expected one of: {:?}", &FIELDS)
5417 }
5418
5419 #[allow(unused_variables)]
5420 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5421 where
5422 E: serde::de::Error,
5423 {
5424 match value {
5425 "config" => Ok(GeneratedField::Config),
5426 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
5427 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
5428 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
5429 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5430 }
5431 }
5432 }
5433 deserializer.deserialize_identifier(GeneratedVisitor)
5434 }
5435 }
5436 struct GeneratedVisitor;
5437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5438 type Value = HnswFlatIndex;
5439
5440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5441 formatter.write_str("struct hummock.HnswFlatIndex")
5442 }
5443
5444 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndex, V::Error>
5445 where
5446 V: serde::de::MapAccess<'de>,
5447 {
5448 let mut config__ = None;
5449 let mut vector_files__ = None;
5450 let mut next_vector_id__ = None;
5451 let mut graph_file__ = None;
5452 while let Some(k) = map_.next_key()? {
5453 match k {
5454 GeneratedField::Config => {
5455 if config__.is_some() {
5456 return Err(serde::de::Error::duplicate_field("config"));
5457 }
5458 config__ = map_.next_value()?;
5459 }
5460 GeneratedField::VectorFiles => {
5461 if vector_files__.is_some() {
5462 return Err(serde::de::Error::duplicate_field("vectorFiles"));
5463 }
5464 vector_files__ = Some(map_.next_value()?);
5465 }
5466 GeneratedField::NextVectorId => {
5467 if next_vector_id__.is_some() {
5468 return Err(serde::de::Error::duplicate_field("nextVectorId"));
5469 }
5470 next_vector_id__ =
5471 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5472 ;
5473 }
5474 GeneratedField::GraphFile => {
5475 if graph_file__.is_some() {
5476 return Err(serde::de::Error::duplicate_field("graphFile"));
5477 }
5478 graph_file__ = map_.next_value()?;
5479 }
5480 }
5481 }
5482 Ok(HnswFlatIndex {
5483 config: config__,
5484 vector_files: vector_files__.unwrap_or_default(),
5485 next_vector_id: next_vector_id__.unwrap_or_default(),
5486 graph_file: graph_file__,
5487 })
5488 }
5489 }
5490 deserializer.deserialize_struct("hummock.HnswFlatIndex", FIELDS, GeneratedVisitor)
5491 }
5492}
5493impl serde::Serialize for HnswFlatIndexAdd {
5494 #[allow(deprecated)]
5495 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5496 where
5497 S: serde::Serializer,
5498 {
5499 use serde::ser::SerializeStruct;
5500 let mut len = 0;
5501 if !self.added_vector_files.is_empty() {
5502 len += 1;
5503 }
5504 if self.next_vector_id != 0 {
5505 len += 1;
5506 }
5507 if self.graph_file.is_some() {
5508 len += 1;
5509 }
5510 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndexAdd", len)?;
5511 if !self.added_vector_files.is_empty() {
5512 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
5513 }
5514 if self.next_vector_id != 0 {
5515 #[allow(clippy::needless_borrow)]
5516 #[allow(clippy::needless_borrows_for_generic_args)]
5517 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5518 }
5519 if let Some(v) = self.graph_file.as_ref() {
5520 struct_ser.serialize_field("graphFile", v)?;
5521 }
5522 struct_ser.end()
5523 }
5524}
5525impl<'de> serde::Deserialize<'de> for HnswFlatIndexAdd {
5526 #[allow(deprecated)]
5527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5528 where
5529 D: serde::Deserializer<'de>,
5530 {
5531 const FIELDS: &[&str] = &[
5532 "added_vector_files",
5533 "addedVectorFiles",
5534 "next_vector_id",
5535 "nextVectorId",
5536 "graph_file",
5537 "graphFile",
5538 ];
5539
5540 #[allow(clippy::enum_variant_names)]
5541 enum GeneratedField {
5542 AddedVectorFiles,
5543 NextVectorId,
5544 GraphFile,
5545 }
5546 impl<'de> serde::Deserialize<'de> for GeneratedField {
5547 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5548 where
5549 D: serde::Deserializer<'de>,
5550 {
5551 struct GeneratedVisitor;
5552
5553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5554 type Value = GeneratedField;
5555
5556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5557 write!(formatter, "expected one of: {:?}", &FIELDS)
5558 }
5559
5560 #[allow(unused_variables)]
5561 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5562 where
5563 E: serde::de::Error,
5564 {
5565 match value {
5566 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
5567 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
5568 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
5569 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5570 }
5571 }
5572 }
5573 deserializer.deserialize_identifier(GeneratedVisitor)
5574 }
5575 }
5576 struct GeneratedVisitor;
5577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5578 type Value = HnswFlatIndexAdd;
5579
5580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5581 formatter.write_str("struct hummock.HnswFlatIndexAdd")
5582 }
5583
5584 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndexAdd, V::Error>
5585 where
5586 V: serde::de::MapAccess<'de>,
5587 {
5588 let mut added_vector_files__ = None;
5589 let mut next_vector_id__ = None;
5590 let mut graph_file__ = None;
5591 while let Some(k) = map_.next_key()? {
5592 match k {
5593 GeneratedField::AddedVectorFiles => {
5594 if added_vector_files__.is_some() {
5595 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
5596 }
5597 added_vector_files__ = Some(map_.next_value()?);
5598 }
5599 GeneratedField::NextVectorId => {
5600 if next_vector_id__.is_some() {
5601 return Err(serde::de::Error::duplicate_field("nextVectorId"));
5602 }
5603 next_vector_id__ =
5604 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5605 ;
5606 }
5607 GeneratedField::GraphFile => {
5608 if graph_file__.is_some() {
5609 return Err(serde::de::Error::duplicate_field("graphFile"));
5610 }
5611 graph_file__ = map_.next_value()?;
5612 }
5613 }
5614 }
5615 Ok(HnswFlatIndexAdd {
5616 added_vector_files: added_vector_files__.unwrap_or_default(),
5617 next_vector_id: next_vector_id__.unwrap_or_default(),
5618 graph_file: graph_file__,
5619 })
5620 }
5621 }
5622 deserializer.deserialize_struct("hummock.HnswFlatIndexAdd", FIELDS, GeneratedVisitor)
5623 }
5624}
5625impl serde::Serialize for HnswGraph {
5626 #[allow(deprecated)]
5627 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5628 where
5629 S: serde::Serializer,
5630 {
5631 use serde::ser::SerializeStruct;
5632 let mut len = 0;
5633 if !self.nodes.is_empty() {
5634 len += 1;
5635 }
5636 if self.entrypoint_id != 0 {
5637 len += 1;
5638 }
5639 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph", len)?;
5640 if !self.nodes.is_empty() {
5641 struct_ser.serialize_field("nodes", &self.nodes)?;
5642 }
5643 if self.entrypoint_id != 0 {
5644 #[allow(clippy::needless_borrow)]
5645 #[allow(clippy::needless_borrows_for_generic_args)]
5646 struct_ser.serialize_field("entrypointId", ToString::to_string(&self.entrypoint_id).as_str())?;
5647 }
5648 struct_ser.end()
5649 }
5650}
5651impl<'de> serde::Deserialize<'de> for HnswGraph {
5652 #[allow(deprecated)]
5653 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5654 where
5655 D: serde::Deserializer<'de>,
5656 {
5657 const FIELDS: &[&str] = &[
5658 "nodes",
5659 "entrypoint_id",
5660 "entrypointId",
5661 ];
5662
5663 #[allow(clippy::enum_variant_names)]
5664 enum GeneratedField {
5665 Nodes,
5666 EntrypointId,
5667 }
5668 impl<'de> serde::Deserialize<'de> for GeneratedField {
5669 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5670 where
5671 D: serde::Deserializer<'de>,
5672 {
5673 struct GeneratedVisitor;
5674
5675 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5676 type Value = GeneratedField;
5677
5678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5679 write!(formatter, "expected one of: {:?}", &FIELDS)
5680 }
5681
5682 #[allow(unused_variables)]
5683 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5684 where
5685 E: serde::de::Error,
5686 {
5687 match value {
5688 "nodes" => Ok(GeneratedField::Nodes),
5689 "entrypointId" | "entrypoint_id" => Ok(GeneratedField::EntrypointId),
5690 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5691 }
5692 }
5693 }
5694 deserializer.deserialize_identifier(GeneratedVisitor)
5695 }
5696 }
5697 struct GeneratedVisitor;
5698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5699 type Value = HnswGraph;
5700
5701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5702 formatter.write_str("struct hummock.HnswGraph")
5703 }
5704
5705 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraph, V::Error>
5706 where
5707 V: serde::de::MapAccess<'de>,
5708 {
5709 let mut nodes__ = None;
5710 let mut entrypoint_id__ = None;
5711 while let Some(k) = map_.next_key()? {
5712 match k {
5713 GeneratedField::Nodes => {
5714 if nodes__.is_some() {
5715 return Err(serde::de::Error::duplicate_field("nodes"));
5716 }
5717 nodes__ = Some(map_.next_value()?);
5718 }
5719 GeneratedField::EntrypointId => {
5720 if entrypoint_id__.is_some() {
5721 return Err(serde::de::Error::duplicate_field("entrypointId"));
5722 }
5723 entrypoint_id__ =
5724 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5725 ;
5726 }
5727 }
5728 }
5729 Ok(HnswGraph {
5730 nodes: nodes__.unwrap_or_default(),
5731 entrypoint_id: entrypoint_id__.unwrap_or_default(),
5732 })
5733 }
5734 }
5735 deserializer.deserialize_struct("hummock.HnswGraph", FIELDS, GeneratedVisitor)
5736 }
5737}
5738impl serde::Serialize for hnsw_graph::HnswLevel {
5739 #[allow(deprecated)]
5740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5741 where
5742 S: serde::Serializer,
5743 {
5744 use serde::ser::SerializeStruct;
5745 let mut len = 0;
5746 if !self.neighbors.is_empty() {
5747 len += 1;
5748 }
5749 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswLevel", len)?;
5750 if !self.neighbors.is_empty() {
5751 struct_ser.serialize_field("neighbors", &self.neighbors)?;
5752 }
5753 struct_ser.end()
5754 }
5755}
5756impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswLevel {
5757 #[allow(deprecated)]
5758 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5759 where
5760 D: serde::Deserializer<'de>,
5761 {
5762 const FIELDS: &[&str] = &[
5763 "neighbors",
5764 ];
5765
5766 #[allow(clippy::enum_variant_names)]
5767 enum GeneratedField {
5768 Neighbors,
5769 }
5770 impl<'de> serde::Deserialize<'de> for GeneratedField {
5771 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5772 where
5773 D: serde::Deserializer<'de>,
5774 {
5775 struct GeneratedVisitor;
5776
5777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5778 type Value = GeneratedField;
5779
5780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5781 write!(formatter, "expected one of: {:?}", &FIELDS)
5782 }
5783
5784 #[allow(unused_variables)]
5785 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5786 where
5787 E: serde::de::Error,
5788 {
5789 match value {
5790 "neighbors" => Ok(GeneratedField::Neighbors),
5791 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5792 }
5793 }
5794 }
5795 deserializer.deserialize_identifier(GeneratedVisitor)
5796 }
5797 }
5798 struct GeneratedVisitor;
5799 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5800 type Value = hnsw_graph::HnswLevel;
5801
5802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5803 formatter.write_str("struct hummock.HnswGraph.HnswLevel")
5804 }
5805
5806 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswLevel, V::Error>
5807 where
5808 V: serde::de::MapAccess<'de>,
5809 {
5810 let mut neighbors__ = None;
5811 while let Some(k) = map_.next_key()? {
5812 match k {
5813 GeneratedField::Neighbors => {
5814 if neighbors__.is_some() {
5815 return Err(serde::de::Error::duplicate_field("neighbors"));
5816 }
5817 neighbors__ = Some(map_.next_value()?);
5818 }
5819 }
5820 }
5821 Ok(hnsw_graph::HnswLevel {
5822 neighbors: neighbors__.unwrap_or_default(),
5823 })
5824 }
5825 }
5826 deserializer.deserialize_struct("hummock.HnswGraph.HnswLevel", FIELDS, GeneratedVisitor)
5827 }
5828}
5829impl serde::Serialize for hnsw_graph::HnswNeighbor {
5830 #[allow(deprecated)]
5831 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5832 where
5833 S: serde::Serializer,
5834 {
5835 use serde::ser::SerializeStruct;
5836 let mut len = 0;
5837 if self.vector_id != 0 {
5838 len += 1;
5839 }
5840 if self.distance != 0. {
5841 len += 1;
5842 }
5843 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNeighbor", len)?;
5844 if self.vector_id != 0 {
5845 #[allow(clippy::needless_borrow)]
5846 #[allow(clippy::needless_borrows_for_generic_args)]
5847 struct_ser.serialize_field("vectorId", ToString::to_string(&self.vector_id).as_str())?;
5848 }
5849 if self.distance != 0. {
5850 struct_ser.serialize_field("distance", &self.distance)?;
5851 }
5852 struct_ser.end()
5853 }
5854}
5855impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNeighbor {
5856 #[allow(deprecated)]
5857 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5858 where
5859 D: serde::Deserializer<'de>,
5860 {
5861 const FIELDS: &[&str] = &[
5862 "vector_id",
5863 "vectorId",
5864 "distance",
5865 ];
5866
5867 #[allow(clippy::enum_variant_names)]
5868 enum GeneratedField {
5869 VectorId,
5870 Distance,
5871 }
5872 impl<'de> serde::Deserialize<'de> for GeneratedField {
5873 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5874 where
5875 D: serde::Deserializer<'de>,
5876 {
5877 struct GeneratedVisitor;
5878
5879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5880 type Value = GeneratedField;
5881
5882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5883 write!(formatter, "expected one of: {:?}", &FIELDS)
5884 }
5885
5886 #[allow(unused_variables)]
5887 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5888 where
5889 E: serde::de::Error,
5890 {
5891 match value {
5892 "vectorId" | "vector_id" => Ok(GeneratedField::VectorId),
5893 "distance" => Ok(GeneratedField::Distance),
5894 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5895 }
5896 }
5897 }
5898 deserializer.deserialize_identifier(GeneratedVisitor)
5899 }
5900 }
5901 struct GeneratedVisitor;
5902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5903 type Value = hnsw_graph::HnswNeighbor;
5904
5905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5906 formatter.write_str("struct hummock.HnswGraph.HnswNeighbor")
5907 }
5908
5909 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNeighbor, V::Error>
5910 where
5911 V: serde::de::MapAccess<'de>,
5912 {
5913 let mut vector_id__ = None;
5914 let mut distance__ = None;
5915 while let Some(k) = map_.next_key()? {
5916 match k {
5917 GeneratedField::VectorId => {
5918 if vector_id__.is_some() {
5919 return Err(serde::de::Error::duplicate_field("vectorId"));
5920 }
5921 vector_id__ =
5922 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5923 ;
5924 }
5925 GeneratedField::Distance => {
5926 if distance__.is_some() {
5927 return Err(serde::de::Error::duplicate_field("distance"));
5928 }
5929 distance__ =
5930 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5931 ;
5932 }
5933 }
5934 }
5935 Ok(hnsw_graph::HnswNeighbor {
5936 vector_id: vector_id__.unwrap_or_default(),
5937 distance: distance__.unwrap_or_default(),
5938 })
5939 }
5940 }
5941 deserializer.deserialize_struct("hummock.HnswGraph.HnswNeighbor", FIELDS, GeneratedVisitor)
5942 }
5943}
5944impl serde::Serialize for hnsw_graph::HnswNode {
5945 #[allow(deprecated)]
5946 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5947 where
5948 S: serde::Serializer,
5949 {
5950 use serde::ser::SerializeStruct;
5951 let mut len = 0;
5952 if !self.levels.is_empty() {
5953 len += 1;
5954 }
5955 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNode", len)?;
5956 if !self.levels.is_empty() {
5957 struct_ser.serialize_field("levels", &self.levels)?;
5958 }
5959 struct_ser.end()
5960 }
5961}
5962impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNode {
5963 #[allow(deprecated)]
5964 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5965 where
5966 D: serde::Deserializer<'de>,
5967 {
5968 const FIELDS: &[&str] = &[
5969 "levels",
5970 ];
5971
5972 #[allow(clippy::enum_variant_names)]
5973 enum GeneratedField {
5974 Levels,
5975 }
5976 impl<'de> serde::Deserialize<'de> for GeneratedField {
5977 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5978 where
5979 D: serde::Deserializer<'de>,
5980 {
5981 struct GeneratedVisitor;
5982
5983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5984 type Value = GeneratedField;
5985
5986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5987 write!(formatter, "expected one of: {:?}", &FIELDS)
5988 }
5989
5990 #[allow(unused_variables)]
5991 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5992 where
5993 E: serde::de::Error,
5994 {
5995 match value {
5996 "levels" => Ok(GeneratedField::Levels),
5997 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5998 }
5999 }
6000 }
6001 deserializer.deserialize_identifier(GeneratedVisitor)
6002 }
6003 }
6004 struct GeneratedVisitor;
6005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6006 type Value = hnsw_graph::HnswNode;
6007
6008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6009 formatter.write_str("struct hummock.HnswGraph.HnswNode")
6010 }
6011
6012 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNode, V::Error>
6013 where
6014 V: serde::de::MapAccess<'de>,
6015 {
6016 let mut levels__ = None;
6017 while let Some(k) = map_.next_key()? {
6018 match k {
6019 GeneratedField::Levels => {
6020 if levels__.is_some() {
6021 return Err(serde::de::Error::duplicate_field("levels"));
6022 }
6023 levels__ = Some(map_.next_value()?);
6024 }
6025 }
6026 }
6027 Ok(hnsw_graph::HnswNode {
6028 levels: levels__.unwrap_or_default(),
6029 })
6030 }
6031 }
6032 deserializer.deserialize_struct("hummock.HnswGraph.HnswNode", FIELDS, GeneratedVisitor)
6033 }
6034}
6035impl serde::Serialize for HnswGraphFileInfo {
6036 #[allow(deprecated)]
6037 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6038 where
6039 S: serde::Serializer,
6040 {
6041 use serde::ser::SerializeStruct;
6042 let mut len = 0;
6043 if self.object_id != 0 {
6044 len += 1;
6045 }
6046 if self.file_size != 0 {
6047 len += 1;
6048 }
6049 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraphFileInfo", len)?;
6050 if self.object_id != 0 {
6051 #[allow(clippy::needless_borrow)]
6052 #[allow(clippy::needless_borrows_for_generic_args)]
6053 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
6054 }
6055 if self.file_size != 0 {
6056 #[allow(clippy::needless_borrow)]
6057 #[allow(clippy::needless_borrows_for_generic_args)]
6058 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
6059 }
6060 struct_ser.end()
6061 }
6062}
6063impl<'de> serde::Deserialize<'de> for HnswGraphFileInfo {
6064 #[allow(deprecated)]
6065 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6066 where
6067 D: serde::Deserializer<'de>,
6068 {
6069 const FIELDS: &[&str] = &[
6070 "object_id",
6071 "objectId",
6072 "file_size",
6073 "fileSize",
6074 ];
6075
6076 #[allow(clippy::enum_variant_names)]
6077 enum GeneratedField {
6078 ObjectId,
6079 FileSize,
6080 }
6081 impl<'de> serde::Deserialize<'de> for GeneratedField {
6082 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6083 where
6084 D: serde::Deserializer<'de>,
6085 {
6086 struct GeneratedVisitor;
6087
6088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6089 type Value = GeneratedField;
6090
6091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6092 write!(formatter, "expected one of: {:?}", &FIELDS)
6093 }
6094
6095 #[allow(unused_variables)]
6096 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6097 where
6098 E: serde::de::Error,
6099 {
6100 match value {
6101 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
6102 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
6103 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6104 }
6105 }
6106 }
6107 deserializer.deserialize_identifier(GeneratedVisitor)
6108 }
6109 }
6110 struct GeneratedVisitor;
6111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6112 type Value = HnswGraphFileInfo;
6113
6114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6115 formatter.write_str("struct hummock.HnswGraphFileInfo")
6116 }
6117
6118 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraphFileInfo, V::Error>
6119 where
6120 V: serde::de::MapAccess<'de>,
6121 {
6122 let mut object_id__ = None;
6123 let mut file_size__ = None;
6124 while let Some(k) = map_.next_key()? {
6125 match k {
6126 GeneratedField::ObjectId => {
6127 if object_id__.is_some() {
6128 return Err(serde::de::Error::duplicate_field("objectId"));
6129 }
6130 object_id__ =
6131 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6132 ;
6133 }
6134 GeneratedField::FileSize => {
6135 if file_size__.is_some() {
6136 return Err(serde::de::Error::duplicate_field("fileSize"));
6137 }
6138 file_size__ =
6139 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6140 ;
6141 }
6142 }
6143 }
6144 Ok(HnswGraphFileInfo {
6145 object_id: object_id__.unwrap_or_default(),
6146 file_size: file_size__.unwrap_or_default(),
6147 })
6148 }
6149 }
6150 deserializer.deserialize_struct("hummock.HnswGraphFileInfo", FIELDS, GeneratedVisitor)
6151 }
6152}
6153impl serde::Serialize for HummockPinnedSnapshot {
6154 #[allow(deprecated)]
6155 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6156 where
6157 S: serde::Serializer,
6158 {
6159 use serde::ser::SerializeStruct;
6160 let mut len = 0;
6161 if self.context_id != 0 {
6162 len += 1;
6163 }
6164 if self.minimal_pinned_snapshot != 0 {
6165 len += 1;
6166 }
6167 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
6168 if self.context_id != 0 {
6169 struct_ser.serialize_field("contextId", &self.context_id)?;
6170 }
6171 if self.minimal_pinned_snapshot != 0 {
6172 #[allow(clippy::needless_borrow)]
6173 #[allow(clippy::needless_borrows_for_generic_args)]
6174 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
6175 }
6176 struct_ser.end()
6177 }
6178}
6179impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
6180 #[allow(deprecated)]
6181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6182 where
6183 D: serde::Deserializer<'de>,
6184 {
6185 const FIELDS: &[&str] = &[
6186 "context_id",
6187 "contextId",
6188 "minimal_pinned_snapshot",
6189 "minimalPinnedSnapshot",
6190 ];
6191
6192 #[allow(clippy::enum_variant_names)]
6193 enum GeneratedField {
6194 ContextId,
6195 MinimalPinnedSnapshot,
6196 }
6197 impl<'de> serde::Deserialize<'de> for GeneratedField {
6198 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6199 where
6200 D: serde::Deserializer<'de>,
6201 {
6202 struct GeneratedVisitor;
6203
6204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6205 type Value = GeneratedField;
6206
6207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6208 write!(formatter, "expected one of: {:?}", &FIELDS)
6209 }
6210
6211 #[allow(unused_variables)]
6212 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6213 where
6214 E: serde::de::Error,
6215 {
6216 match value {
6217 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6218 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
6219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6220 }
6221 }
6222 }
6223 deserializer.deserialize_identifier(GeneratedVisitor)
6224 }
6225 }
6226 struct GeneratedVisitor;
6227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6228 type Value = HummockPinnedSnapshot;
6229
6230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6231 formatter.write_str("struct hummock.HummockPinnedSnapshot")
6232 }
6233
6234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
6235 where
6236 V: serde::de::MapAccess<'de>,
6237 {
6238 let mut context_id__ = None;
6239 let mut minimal_pinned_snapshot__ = None;
6240 while let Some(k) = map_.next_key()? {
6241 match k {
6242 GeneratedField::ContextId => {
6243 if context_id__.is_some() {
6244 return Err(serde::de::Error::duplicate_field("contextId"));
6245 }
6246 context_id__ =
6247 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6248 ;
6249 }
6250 GeneratedField::MinimalPinnedSnapshot => {
6251 if minimal_pinned_snapshot__.is_some() {
6252 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
6253 }
6254 minimal_pinned_snapshot__ =
6255 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6256 ;
6257 }
6258 }
6259 }
6260 Ok(HummockPinnedSnapshot {
6261 context_id: context_id__.unwrap_or_default(),
6262 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
6263 })
6264 }
6265 }
6266 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
6267 }
6268}
6269impl serde::Serialize for HummockPinnedVersion {
6270 #[allow(deprecated)]
6271 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6272 where
6273 S: serde::Serializer,
6274 {
6275 use serde::ser::SerializeStruct;
6276 let mut len = 0;
6277 if self.context_id != 0 {
6278 len += 1;
6279 }
6280 if self.min_pinned_id != 0 {
6281 len += 1;
6282 }
6283 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
6284 if self.context_id != 0 {
6285 struct_ser.serialize_field("contextId", &self.context_id)?;
6286 }
6287 if self.min_pinned_id != 0 {
6288 #[allow(clippy::needless_borrow)]
6289 #[allow(clippy::needless_borrows_for_generic_args)]
6290 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
6291 }
6292 struct_ser.end()
6293 }
6294}
6295impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
6296 #[allow(deprecated)]
6297 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6298 where
6299 D: serde::Deserializer<'de>,
6300 {
6301 const FIELDS: &[&str] = &[
6302 "context_id",
6303 "contextId",
6304 "min_pinned_id",
6305 "minPinnedId",
6306 ];
6307
6308 #[allow(clippy::enum_variant_names)]
6309 enum GeneratedField {
6310 ContextId,
6311 MinPinnedId,
6312 }
6313 impl<'de> serde::Deserialize<'de> for GeneratedField {
6314 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6315 where
6316 D: serde::Deserializer<'de>,
6317 {
6318 struct GeneratedVisitor;
6319
6320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6321 type Value = GeneratedField;
6322
6323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6324 write!(formatter, "expected one of: {:?}", &FIELDS)
6325 }
6326
6327 #[allow(unused_variables)]
6328 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6329 where
6330 E: serde::de::Error,
6331 {
6332 match value {
6333 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6334 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
6335 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6336 }
6337 }
6338 }
6339 deserializer.deserialize_identifier(GeneratedVisitor)
6340 }
6341 }
6342 struct GeneratedVisitor;
6343 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6344 type Value = HummockPinnedVersion;
6345
6346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6347 formatter.write_str("struct hummock.HummockPinnedVersion")
6348 }
6349
6350 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
6351 where
6352 V: serde::de::MapAccess<'de>,
6353 {
6354 let mut context_id__ = None;
6355 let mut min_pinned_id__ = None;
6356 while let Some(k) = map_.next_key()? {
6357 match k {
6358 GeneratedField::ContextId => {
6359 if context_id__.is_some() {
6360 return Err(serde::de::Error::duplicate_field("contextId"));
6361 }
6362 context_id__ =
6363 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6364 ;
6365 }
6366 GeneratedField::MinPinnedId => {
6367 if min_pinned_id__.is_some() {
6368 return Err(serde::de::Error::duplicate_field("minPinnedId"));
6369 }
6370 min_pinned_id__ =
6371 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6372 ;
6373 }
6374 }
6375 }
6376 Ok(HummockPinnedVersion {
6377 context_id: context_id__.unwrap_or_default(),
6378 min_pinned_id: min_pinned_id__.unwrap_or_default(),
6379 })
6380 }
6381 }
6382 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
6383 }
6384}
6385impl serde::Serialize for HummockVersion {
6386 #[allow(deprecated)]
6387 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6388 where
6389 S: serde::Serializer,
6390 {
6391 use serde::ser::SerializeStruct;
6392 let mut len = 0;
6393 if self.id != 0 {
6394 len += 1;
6395 }
6396 if !self.levels.is_empty() {
6397 len += 1;
6398 }
6399 if self.max_committed_epoch != 0 {
6400 len += 1;
6401 }
6402 if !self.table_watermarks.is_empty() {
6403 len += 1;
6404 }
6405 if !self.table_change_logs.is_empty() {
6406 len += 1;
6407 }
6408 if !self.state_table_info.is_empty() {
6409 len += 1;
6410 }
6411 if !self.vector_indexes.is_empty() {
6412 len += 1;
6413 }
6414 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
6415 if self.id != 0 {
6416 #[allow(clippy::needless_borrow)]
6417 #[allow(clippy::needless_borrows_for_generic_args)]
6418 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6419 }
6420 if !self.levels.is_empty() {
6421 struct_ser.serialize_field("levels", &self.levels)?;
6422 }
6423 if self.max_committed_epoch != 0 {
6424 #[allow(clippy::needless_borrow)]
6425 #[allow(clippy::needless_borrows_for_generic_args)]
6426 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6427 }
6428 if !self.table_watermarks.is_empty() {
6429 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
6430 }
6431 if !self.table_change_logs.is_empty() {
6432 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
6433 }
6434 if !self.state_table_info.is_empty() {
6435 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
6436 }
6437 if !self.vector_indexes.is_empty() {
6438 struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
6439 }
6440 struct_ser.end()
6441 }
6442}
6443impl<'de> serde::Deserialize<'de> for HummockVersion {
6444 #[allow(deprecated)]
6445 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6446 where
6447 D: serde::Deserializer<'de>,
6448 {
6449 const FIELDS: &[&str] = &[
6450 "id",
6451 "levels",
6452 "max_committed_epoch",
6453 "maxCommittedEpoch",
6454 "table_watermarks",
6455 "tableWatermarks",
6456 "table_change_logs",
6457 "tableChangeLogs",
6458 "state_table_info",
6459 "stateTableInfo",
6460 "vector_indexes",
6461 "vectorIndexes",
6462 ];
6463
6464 #[allow(clippy::enum_variant_names)]
6465 enum GeneratedField {
6466 Id,
6467 Levels,
6468 MaxCommittedEpoch,
6469 TableWatermarks,
6470 TableChangeLogs,
6471 StateTableInfo,
6472 VectorIndexes,
6473 }
6474 impl<'de> serde::Deserialize<'de> for GeneratedField {
6475 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6476 where
6477 D: serde::Deserializer<'de>,
6478 {
6479 struct GeneratedVisitor;
6480
6481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6482 type Value = GeneratedField;
6483
6484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6485 write!(formatter, "expected one of: {:?}", &FIELDS)
6486 }
6487
6488 #[allow(unused_variables)]
6489 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6490 where
6491 E: serde::de::Error,
6492 {
6493 match value {
6494 "id" => Ok(GeneratedField::Id),
6495 "levels" => Ok(GeneratedField::Levels),
6496 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6497 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
6498 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
6499 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
6500 "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
6501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6502 }
6503 }
6504 }
6505 deserializer.deserialize_identifier(GeneratedVisitor)
6506 }
6507 }
6508 struct GeneratedVisitor;
6509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6510 type Value = HummockVersion;
6511
6512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6513 formatter.write_str("struct hummock.HummockVersion")
6514 }
6515
6516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
6517 where
6518 V: serde::de::MapAccess<'de>,
6519 {
6520 let mut id__ = None;
6521 let mut levels__ = None;
6522 let mut max_committed_epoch__ = None;
6523 let mut table_watermarks__ = None;
6524 let mut table_change_logs__ = None;
6525 let mut state_table_info__ = None;
6526 let mut vector_indexes__ = None;
6527 while let Some(k) = map_.next_key()? {
6528 match k {
6529 GeneratedField::Id => {
6530 if id__.is_some() {
6531 return Err(serde::de::Error::duplicate_field("id"));
6532 }
6533 id__ =
6534 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6535 ;
6536 }
6537 GeneratedField::Levels => {
6538 if levels__.is_some() {
6539 return Err(serde::de::Error::duplicate_field("levels"));
6540 }
6541 levels__ = Some(
6542 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6543 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6544 );
6545 }
6546 GeneratedField::MaxCommittedEpoch => {
6547 if max_committed_epoch__.is_some() {
6548 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
6549 }
6550 max_committed_epoch__ =
6551 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6552 ;
6553 }
6554 GeneratedField::TableWatermarks => {
6555 if table_watermarks__.is_some() {
6556 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
6557 }
6558 table_watermarks__ = Some(
6559 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6560 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6561 );
6562 }
6563 GeneratedField::TableChangeLogs => {
6564 if table_change_logs__.is_some() {
6565 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
6566 }
6567 table_change_logs__ = Some(
6568 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6569 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6570 );
6571 }
6572 GeneratedField::StateTableInfo => {
6573 if state_table_info__.is_some() {
6574 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
6575 }
6576 state_table_info__ = Some(
6577 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6578 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6579 );
6580 }
6581 GeneratedField::VectorIndexes => {
6582 if vector_indexes__.is_some() {
6583 return Err(serde::de::Error::duplicate_field("vectorIndexes"));
6584 }
6585 vector_indexes__ = Some(
6586 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6587 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6588 );
6589 }
6590 }
6591 }
6592 Ok(HummockVersion {
6593 id: id__.unwrap_or_default(),
6594 levels: levels__.unwrap_or_default(),
6595 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
6596 table_watermarks: table_watermarks__.unwrap_or_default(),
6597 table_change_logs: table_change_logs__.unwrap_or_default(),
6598 state_table_info: state_table_info__.unwrap_or_default(),
6599 vector_indexes: vector_indexes__.unwrap_or_default(),
6600 })
6601 }
6602 }
6603 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
6604 }
6605}
6606impl serde::Serialize for hummock_version::Levels {
6607 #[allow(deprecated)]
6608 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6609 where
6610 S: serde::Serializer,
6611 {
6612 use serde::ser::SerializeStruct;
6613 let mut len = 0;
6614 if !self.levels.is_empty() {
6615 len += 1;
6616 }
6617 if self.l0.is_some() {
6618 len += 1;
6619 }
6620 if self.group_id != 0 {
6621 len += 1;
6622 }
6623 if self.parent_group_id != 0 {
6624 len += 1;
6625 }
6626 if !self.member_table_ids.is_empty() {
6627 len += 1;
6628 }
6629 if self.compaction_group_version_id != 0 {
6630 len += 1;
6631 }
6632 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
6633 if !self.levels.is_empty() {
6634 struct_ser.serialize_field("levels", &self.levels)?;
6635 }
6636 if let Some(v) = self.l0.as_ref() {
6637 struct_ser.serialize_field("l0", v)?;
6638 }
6639 if self.group_id != 0 {
6640 #[allow(clippy::needless_borrow)]
6641 #[allow(clippy::needless_borrows_for_generic_args)]
6642 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
6643 }
6644 if self.parent_group_id != 0 {
6645 #[allow(clippy::needless_borrow)]
6646 #[allow(clippy::needless_borrows_for_generic_args)]
6647 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
6648 }
6649 if !self.member_table_ids.is_empty() {
6650 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
6651 }
6652 if self.compaction_group_version_id != 0 {
6653 #[allow(clippy::needless_borrow)]
6654 #[allow(clippy::needless_borrows_for_generic_args)]
6655 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
6656 }
6657 struct_ser.end()
6658 }
6659}
6660impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
6661 #[allow(deprecated)]
6662 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6663 where
6664 D: serde::Deserializer<'de>,
6665 {
6666 const FIELDS: &[&str] = &[
6667 "levels",
6668 "l0",
6669 "group_id",
6670 "groupId",
6671 "parent_group_id",
6672 "parentGroupId",
6673 "member_table_ids",
6674 "memberTableIds",
6675 "compaction_group_version_id",
6676 "compactionGroupVersionId",
6677 ];
6678
6679 #[allow(clippy::enum_variant_names)]
6680 enum GeneratedField {
6681 Levels,
6682 L0,
6683 GroupId,
6684 ParentGroupId,
6685 MemberTableIds,
6686 CompactionGroupVersionId,
6687 }
6688 impl<'de> serde::Deserialize<'de> for GeneratedField {
6689 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6690 where
6691 D: serde::Deserializer<'de>,
6692 {
6693 struct GeneratedVisitor;
6694
6695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6696 type Value = GeneratedField;
6697
6698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6699 write!(formatter, "expected one of: {:?}", &FIELDS)
6700 }
6701
6702 #[allow(unused_variables)]
6703 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6704 where
6705 E: serde::de::Error,
6706 {
6707 match value {
6708 "levels" => Ok(GeneratedField::Levels),
6709 "l0" => Ok(GeneratedField::L0),
6710 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
6711 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
6712 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
6713 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
6714 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6715 }
6716 }
6717 }
6718 deserializer.deserialize_identifier(GeneratedVisitor)
6719 }
6720 }
6721 struct GeneratedVisitor;
6722 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6723 type Value = hummock_version::Levels;
6724
6725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6726 formatter.write_str("struct hummock.HummockVersion.Levels")
6727 }
6728
6729 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
6730 where
6731 V: serde::de::MapAccess<'de>,
6732 {
6733 let mut levels__ = None;
6734 let mut l0__ = None;
6735 let mut group_id__ = None;
6736 let mut parent_group_id__ = None;
6737 let mut member_table_ids__ = None;
6738 let mut compaction_group_version_id__ = None;
6739 while let Some(k) = map_.next_key()? {
6740 match k {
6741 GeneratedField::Levels => {
6742 if levels__.is_some() {
6743 return Err(serde::de::Error::duplicate_field("levels"));
6744 }
6745 levels__ = Some(map_.next_value()?);
6746 }
6747 GeneratedField::L0 => {
6748 if l0__.is_some() {
6749 return Err(serde::de::Error::duplicate_field("l0"));
6750 }
6751 l0__ = map_.next_value()?;
6752 }
6753 GeneratedField::GroupId => {
6754 if group_id__.is_some() {
6755 return Err(serde::de::Error::duplicate_field("groupId"));
6756 }
6757 group_id__ =
6758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6759 ;
6760 }
6761 GeneratedField::ParentGroupId => {
6762 if parent_group_id__.is_some() {
6763 return Err(serde::de::Error::duplicate_field("parentGroupId"));
6764 }
6765 parent_group_id__ =
6766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6767 ;
6768 }
6769 GeneratedField::MemberTableIds => {
6770 if member_table_ids__.is_some() {
6771 return Err(serde::de::Error::duplicate_field("memberTableIds"));
6772 }
6773 member_table_ids__ =
6774 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6775 .into_iter().map(|x| x.0).collect())
6776 ;
6777 }
6778 GeneratedField::CompactionGroupVersionId => {
6779 if compaction_group_version_id__.is_some() {
6780 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
6781 }
6782 compaction_group_version_id__ =
6783 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6784 ;
6785 }
6786 }
6787 }
6788 Ok(hummock_version::Levels {
6789 levels: levels__.unwrap_or_default(),
6790 l0: l0__,
6791 group_id: group_id__.unwrap_or_default(),
6792 parent_group_id: parent_group_id__.unwrap_or_default(),
6793 member_table_ids: member_table_ids__.unwrap_or_default(),
6794 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
6795 })
6796 }
6797 }
6798 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
6799 }
6800}
6801impl serde::Serialize for HummockVersionArchive {
6802 #[allow(deprecated)]
6803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6804 where
6805 S: serde::Serializer,
6806 {
6807 use serde::ser::SerializeStruct;
6808 let mut len = 0;
6809 if self.version.is_some() {
6810 len += 1;
6811 }
6812 if !self.version_deltas.is_empty() {
6813 len += 1;
6814 }
6815 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
6816 if let Some(v) = self.version.as_ref() {
6817 struct_ser.serialize_field("version", v)?;
6818 }
6819 if !self.version_deltas.is_empty() {
6820 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6821 }
6822 struct_ser.end()
6823 }
6824}
6825impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
6826 #[allow(deprecated)]
6827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6828 where
6829 D: serde::Deserializer<'de>,
6830 {
6831 const FIELDS: &[&str] = &[
6832 "version",
6833 "version_deltas",
6834 "versionDeltas",
6835 ];
6836
6837 #[allow(clippy::enum_variant_names)]
6838 enum GeneratedField {
6839 Version,
6840 VersionDeltas,
6841 }
6842 impl<'de> serde::Deserialize<'de> for GeneratedField {
6843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6844 where
6845 D: serde::Deserializer<'de>,
6846 {
6847 struct GeneratedVisitor;
6848
6849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6850 type Value = GeneratedField;
6851
6852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6853 write!(formatter, "expected one of: {:?}", &FIELDS)
6854 }
6855
6856 #[allow(unused_variables)]
6857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6858 where
6859 E: serde::de::Error,
6860 {
6861 match value {
6862 "version" => Ok(GeneratedField::Version),
6863 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6864 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6865 }
6866 }
6867 }
6868 deserializer.deserialize_identifier(GeneratedVisitor)
6869 }
6870 }
6871 struct GeneratedVisitor;
6872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6873 type Value = HummockVersionArchive;
6874
6875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6876 formatter.write_str("struct hummock.HummockVersionArchive")
6877 }
6878
6879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
6880 where
6881 V: serde::de::MapAccess<'de>,
6882 {
6883 let mut version__ = None;
6884 let mut version_deltas__ = None;
6885 while let Some(k) = map_.next_key()? {
6886 match k {
6887 GeneratedField::Version => {
6888 if version__.is_some() {
6889 return Err(serde::de::Error::duplicate_field("version"));
6890 }
6891 version__ = map_.next_value()?;
6892 }
6893 GeneratedField::VersionDeltas => {
6894 if version_deltas__.is_some() {
6895 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6896 }
6897 version_deltas__ = Some(map_.next_value()?);
6898 }
6899 }
6900 }
6901 Ok(HummockVersionArchive {
6902 version: version__,
6903 version_deltas: version_deltas__.unwrap_or_default(),
6904 })
6905 }
6906 }
6907 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
6908 }
6909}
6910impl serde::Serialize for HummockVersionCheckpoint {
6911 #[allow(deprecated)]
6912 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6913 where
6914 S: serde::Serializer,
6915 {
6916 use serde::ser::SerializeStruct;
6917 let mut len = 0;
6918 if self.version.is_some() {
6919 len += 1;
6920 }
6921 if !self.stale_objects.is_empty() {
6922 len += 1;
6923 }
6924 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
6925 if let Some(v) = self.version.as_ref() {
6926 struct_ser.serialize_field("version", v)?;
6927 }
6928 if !self.stale_objects.is_empty() {
6929 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
6930 }
6931 struct_ser.end()
6932 }
6933}
6934impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
6935 #[allow(deprecated)]
6936 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6937 where
6938 D: serde::Deserializer<'de>,
6939 {
6940 const FIELDS: &[&str] = &[
6941 "version",
6942 "stale_objects",
6943 "staleObjects",
6944 ];
6945
6946 #[allow(clippy::enum_variant_names)]
6947 enum GeneratedField {
6948 Version,
6949 StaleObjects,
6950 }
6951 impl<'de> serde::Deserialize<'de> for GeneratedField {
6952 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6953 where
6954 D: serde::Deserializer<'de>,
6955 {
6956 struct GeneratedVisitor;
6957
6958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6959 type Value = GeneratedField;
6960
6961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6962 write!(formatter, "expected one of: {:?}", &FIELDS)
6963 }
6964
6965 #[allow(unused_variables)]
6966 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6967 where
6968 E: serde::de::Error,
6969 {
6970 match value {
6971 "version" => Ok(GeneratedField::Version),
6972 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
6973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6974 }
6975 }
6976 }
6977 deserializer.deserialize_identifier(GeneratedVisitor)
6978 }
6979 }
6980 struct GeneratedVisitor;
6981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6982 type Value = HummockVersionCheckpoint;
6983
6984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6985 formatter.write_str("struct hummock.HummockVersionCheckpoint")
6986 }
6987
6988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
6989 where
6990 V: serde::de::MapAccess<'de>,
6991 {
6992 let mut version__ = None;
6993 let mut stale_objects__ = None;
6994 while let Some(k) = map_.next_key()? {
6995 match k {
6996 GeneratedField::Version => {
6997 if version__.is_some() {
6998 return Err(serde::de::Error::duplicate_field("version"));
6999 }
7000 version__ = map_.next_value()?;
7001 }
7002 GeneratedField::StaleObjects => {
7003 if stale_objects__.is_some() {
7004 return Err(serde::de::Error::duplicate_field("staleObjects"));
7005 }
7006 stale_objects__ = Some(
7007 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7008 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7009 );
7010 }
7011 }
7012 }
7013 Ok(HummockVersionCheckpoint {
7014 version: version__,
7015 stale_objects: stale_objects__.unwrap_or_default(),
7016 })
7017 }
7018 }
7019 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
7020 }
7021}
7022impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
7023 #[allow(deprecated)]
7024 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7025 where
7026 S: serde::Serializer,
7027 {
7028 use serde::ser::SerializeStruct;
7029 let mut len = 0;
7030 if !self.id.is_empty() {
7031 len += 1;
7032 }
7033 if self.total_file_size != 0 {
7034 len += 1;
7035 }
7036 if !self.vector_files.is_empty() {
7037 len += 1;
7038 }
7039 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
7040 if !self.id.is_empty() {
7041 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7042 }
7043 if self.total_file_size != 0 {
7044 #[allow(clippy::needless_borrow)]
7045 #[allow(clippy::needless_borrows_for_generic_args)]
7046 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7047 }
7048 if !self.vector_files.is_empty() {
7049 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
7050 }
7051 struct_ser.end()
7052 }
7053}
7054impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
7055 #[allow(deprecated)]
7056 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7057 where
7058 D: serde::Deserializer<'de>,
7059 {
7060 const FIELDS: &[&str] = &[
7061 "id",
7062 "total_file_size",
7063 "totalFileSize",
7064 "vector_files",
7065 "vectorFiles",
7066 ];
7067
7068 #[allow(clippy::enum_variant_names)]
7069 enum GeneratedField {
7070 Id,
7071 TotalFileSize,
7072 VectorFiles,
7073 }
7074 impl<'de> serde::Deserialize<'de> for GeneratedField {
7075 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7076 where
7077 D: serde::Deserializer<'de>,
7078 {
7079 struct GeneratedVisitor;
7080
7081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7082 type Value = GeneratedField;
7083
7084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7085 write!(formatter, "expected one of: {:?}", &FIELDS)
7086 }
7087
7088 #[allow(unused_variables)]
7089 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7090 where
7091 E: serde::de::Error,
7092 {
7093 match value {
7094 "id" => Ok(GeneratedField::Id),
7095 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7096 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
7097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7098 }
7099 }
7100 }
7101 deserializer.deserialize_identifier(GeneratedVisitor)
7102 }
7103 }
7104 struct GeneratedVisitor;
7105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7106 type Value = hummock_version_checkpoint::StaleObjects;
7107
7108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7109 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
7110 }
7111
7112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
7113 where
7114 V: serde::de::MapAccess<'de>,
7115 {
7116 let mut id__ = None;
7117 let mut total_file_size__ = None;
7118 let mut vector_files__ = None;
7119 while let Some(k) = map_.next_key()? {
7120 match k {
7121 GeneratedField::Id => {
7122 if id__.is_some() {
7123 return Err(serde::de::Error::duplicate_field("id"));
7124 }
7125 id__ =
7126 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7127 .into_iter().map(|x| x.0).collect())
7128 ;
7129 }
7130 GeneratedField::TotalFileSize => {
7131 if total_file_size__.is_some() {
7132 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7133 }
7134 total_file_size__ =
7135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7136 ;
7137 }
7138 GeneratedField::VectorFiles => {
7139 if vector_files__.is_some() {
7140 return Err(serde::de::Error::duplicate_field("vectorFiles"));
7141 }
7142 vector_files__ = Some(map_.next_value()?);
7143 }
7144 }
7145 }
7146 Ok(hummock_version_checkpoint::StaleObjects {
7147 id: id__.unwrap_or_default(),
7148 total_file_size: total_file_size__.unwrap_or_default(),
7149 vector_files: vector_files__.unwrap_or_default(),
7150 })
7151 }
7152 }
7153 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
7154 }
7155}
7156impl serde::Serialize for HummockVersionDelta {
7157 #[allow(deprecated)]
7158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7159 where
7160 S: serde::Serializer,
7161 {
7162 use serde::ser::SerializeStruct;
7163 let mut len = 0;
7164 if self.id != 0 {
7165 len += 1;
7166 }
7167 if self.prev_id != 0 {
7168 len += 1;
7169 }
7170 if !self.group_deltas.is_empty() {
7171 len += 1;
7172 }
7173 if self.max_committed_epoch != 0 {
7174 len += 1;
7175 }
7176 if self.trivial_move {
7177 len += 1;
7178 }
7179 if !self.new_table_watermarks.is_empty() {
7180 len += 1;
7181 }
7182 if !self.removed_table_ids.is_empty() {
7183 len += 1;
7184 }
7185 if !self.change_log_delta.is_empty() {
7186 len += 1;
7187 }
7188 if !self.state_table_info_delta.is_empty() {
7189 len += 1;
7190 }
7191 if !self.vector_index_delta.is_empty() {
7192 len += 1;
7193 }
7194 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
7195 if self.id != 0 {
7196 #[allow(clippy::needless_borrow)]
7197 #[allow(clippy::needless_borrows_for_generic_args)]
7198 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7199 }
7200 if self.prev_id != 0 {
7201 #[allow(clippy::needless_borrow)]
7202 #[allow(clippy::needless_borrows_for_generic_args)]
7203 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
7204 }
7205 if !self.group_deltas.is_empty() {
7206 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7207 }
7208 if self.max_committed_epoch != 0 {
7209 #[allow(clippy::needless_borrow)]
7210 #[allow(clippy::needless_borrows_for_generic_args)]
7211 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
7212 }
7213 if self.trivial_move {
7214 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
7215 }
7216 if !self.new_table_watermarks.is_empty() {
7217 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
7218 }
7219 if !self.removed_table_ids.is_empty() {
7220 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
7221 }
7222 if !self.change_log_delta.is_empty() {
7223 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
7224 }
7225 if !self.state_table_info_delta.is_empty() {
7226 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
7227 }
7228 if !self.vector_index_delta.is_empty() {
7229 struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
7230 }
7231 struct_ser.end()
7232 }
7233}
7234impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
7235 #[allow(deprecated)]
7236 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7237 where
7238 D: serde::Deserializer<'de>,
7239 {
7240 const FIELDS: &[&str] = &[
7241 "id",
7242 "prev_id",
7243 "prevId",
7244 "group_deltas",
7245 "groupDeltas",
7246 "max_committed_epoch",
7247 "maxCommittedEpoch",
7248 "trivial_move",
7249 "trivialMove",
7250 "new_table_watermarks",
7251 "newTableWatermarks",
7252 "removed_table_ids",
7253 "removedTableIds",
7254 "change_log_delta",
7255 "changeLogDelta",
7256 "state_table_info_delta",
7257 "stateTableInfoDelta",
7258 "vector_index_delta",
7259 "vectorIndexDelta",
7260 ];
7261
7262 #[allow(clippy::enum_variant_names)]
7263 enum GeneratedField {
7264 Id,
7265 PrevId,
7266 GroupDeltas,
7267 MaxCommittedEpoch,
7268 TrivialMove,
7269 NewTableWatermarks,
7270 RemovedTableIds,
7271 ChangeLogDelta,
7272 StateTableInfoDelta,
7273 VectorIndexDelta,
7274 }
7275 impl<'de> serde::Deserialize<'de> for GeneratedField {
7276 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7277 where
7278 D: serde::Deserializer<'de>,
7279 {
7280 struct GeneratedVisitor;
7281
7282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7283 type Value = GeneratedField;
7284
7285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7286 write!(formatter, "expected one of: {:?}", &FIELDS)
7287 }
7288
7289 #[allow(unused_variables)]
7290 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7291 where
7292 E: serde::de::Error,
7293 {
7294 match value {
7295 "id" => Ok(GeneratedField::Id),
7296 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
7297 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
7298 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
7299 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
7300 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
7301 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7302 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
7303 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
7304 "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
7305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7306 }
7307 }
7308 }
7309 deserializer.deserialize_identifier(GeneratedVisitor)
7310 }
7311 }
7312 struct GeneratedVisitor;
7313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7314 type Value = HummockVersionDelta;
7315
7316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7317 formatter.write_str("struct hummock.HummockVersionDelta")
7318 }
7319
7320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
7321 where
7322 V: serde::de::MapAccess<'de>,
7323 {
7324 let mut id__ = None;
7325 let mut prev_id__ = None;
7326 let mut group_deltas__ = None;
7327 let mut max_committed_epoch__ = None;
7328 let mut trivial_move__ = None;
7329 let mut new_table_watermarks__ = None;
7330 let mut removed_table_ids__ = None;
7331 let mut change_log_delta__ = None;
7332 let mut state_table_info_delta__ = None;
7333 let mut vector_index_delta__ = None;
7334 while let Some(k) = map_.next_key()? {
7335 match k {
7336 GeneratedField::Id => {
7337 if id__.is_some() {
7338 return Err(serde::de::Error::duplicate_field("id"));
7339 }
7340 id__ =
7341 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7342 ;
7343 }
7344 GeneratedField::PrevId => {
7345 if prev_id__.is_some() {
7346 return Err(serde::de::Error::duplicate_field("prevId"));
7347 }
7348 prev_id__ =
7349 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7350 ;
7351 }
7352 GeneratedField::GroupDeltas => {
7353 if group_deltas__.is_some() {
7354 return Err(serde::de::Error::duplicate_field("groupDeltas"));
7355 }
7356 group_deltas__ = Some(
7357 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7358 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7359 );
7360 }
7361 GeneratedField::MaxCommittedEpoch => {
7362 if max_committed_epoch__.is_some() {
7363 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
7364 }
7365 max_committed_epoch__ =
7366 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7367 ;
7368 }
7369 GeneratedField::TrivialMove => {
7370 if trivial_move__.is_some() {
7371 return Err(serde::de::Error::duplicate_field("trivialMove"));
7372 }
7373 trivial_move__ = Some(map_.next_value()?);
7374 }
7375 GeneratedField::NewTableWatermarks => {
7376 if new_table_watermarks__.is_some() {
7377 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
7378 }
7379 new_table_watermarks__ = Some(
7380 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7381 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7382 );
7383 }
7384 GeneratedField::RemovedTableIds => {
7385 if removed_table_ids__.is_some() {
7386 return Err(serde::de::Error::duplicate_field("removedTableIds"));
7387 }
7388 removed_table_ids__ =
7389 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7390 .into_iter().map(|x| x.0).collect())
7391 ;
7392 }
7393 GeneratedField::ChangeLogDelta => {
7394 if change_log_delta__.is_some() {
7395 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
7396 }
7397 change_log_delta__ = Some(
7398 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7399 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7400 );
7401 }
7402 GeneratedField::StateTableInfoDelta => {
7403 if state_table_info_delta__.is_some() {
7404 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
7405 }
7406 state_table_info_delta__ = Some(
7407 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7408 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7409 );
7410 }
7411 GeneratedField::VectorIndexDelta => {
7412 if vector_index_delta__.is_some() {
7413 return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
7414 }
7415 vector_index_delta__ = Some(
7416 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7417 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7418 );
7419 }
7420 }
7421 }
7422 Ok(HummockVersionDelta {
7423 id: id__.unwrap_or_default(),
7424 prev_id: prev_id__.unwrap_or_default(),
7425 group_deltas: group_deltas__.unwrap_or_default(),
7426 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
7427 trivial_move: trivial_move__.unwrap_or_default(),
7428 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
7429 removed_table_ids: removed_table_ids__.unwrap_or_default(),
7430 change_log_delta: change_log_delta__.unwrap_or_default(),
7431 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
7432 vector_index_delta: vector_index_delta__.unwrap_or_default(),
7433 })
7434 }
7435 }
7436 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
7437 }
7438}
7439impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
7440 #[allow(deprecated)]
7441 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7442 where
7443 S: serde::Serializer,
7444 {
7445 use serde::ser::SerializeStruct;
7446 let mut len = 0;
7447 if self.new_log.is_some() {
7448 len += 1;
7449 }
7450 if self.truncate_epoch != 0 {
7451 len += 1;
7452 }
7453 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
7454 if let Some(v) = self.new_log.as_ref() {
7455 struct_ser.serialize_field("newLog", v)?;
7456 }
7457 if self.truncate_epoch != 0 {
7458 #[allow(clippy::needless_borrow)]
7459 #[allow(clippy::needless_borrows_for_generic_args)]
7460 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
7461 }
7462 struct_ser.end()
7463 }
7464}
7465impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
7466 #[allow(deprecated)]
7467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7468 where
7469 D: serde::Deserializer<'de>,
7470 {
7471 const FIELDS: &[&str] = &[
7472 "new_log",
7473 "newLog",
7474 "truncate_epoch",
7475 "truncateEpoch",
7476 ];
7477
7478 #[allow(clippy::enum_variant_names)]
7479 enum GeneratedField {
7480 NewLog,
7481 TruncateEpoch,
7482 }
7483 impl<'de> serde::Deserialize<'de> for GeneratedField {
7484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7485 where
7486 D: serde::Deserializer<'de>,
7487 {
7488 struct GeneratedVisitor;
7489
7490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7491 type Value = GeneratedField;
7492
7493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7494 write!(formatter, "expected one of: {:?}", &FIELDS)
7495 }
7496
7497 #[allow(unused_variables)]
7498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7499 where
7500 E: serde::de::Error,
7501 {
7502 match value {
7503 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
7504 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
7505 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7506 }
7507 }
7508 }
7509 deserializer.deserialize_identifier(GeneratedVisitor)
7510 }
7511 }
7512 struct GeneratedVisitor;
7513 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7514 type Value = hummock_version_delta::ChangeLogDelta;
7515
7516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7517 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
7518 }
7519
7520 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
7521 where
7522 V: serde::de::MapAccess<'de>,
7523 {
7524 let mut new_log__ = None;
7525 let mut truncate_epoch__ = None;
7526 while let Some(k) = map_.next_key()? {
7527 match k {
7528 GeneratedField::NewLog => {
7529 if new_log__.is_some() {
7530 return Err(serde::de::Error::duplicate_field("newLog"));
7531 }
7532 new_log__ = map_.next_value()?;
7533 }
7534 GeneratedField::TruncateEpoch => {
7535 if truncate_epoch__.is_some() {
7536 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
7537 }
7538 truncate_epoch__ =
7539 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7540 ;
7541 }
7542 }
7543 }
7544 Ok(hummock_version_delta::ChangeLogDelta {
7545 new_log: new_log__,
7546 truncate_epoch: truncate_epoch__.unwrap_or_default(),
7547 })
7548 }
7549 }
7550 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
7551 }
7552}
7553impl serde::Serialize for hummock_version_delta::GroupDeltas {
7554 #[allow(deprecated)]
7555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7556 where
7557 S: serde::Serializer,
7558 {
7559 use serde::ser::SerializeStruct;
7560 let mut len = 0;
7561 if !self.group_deltas.is_empty() {
7562 len += 1;
7563 }
7564 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
7565 if !self.group_deltas.is_empty() {
7566 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7567 }
7568 struct_ser.end()
7569 }
7570}
7571impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
7572 #[allow(deprecated)]
7573 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7574 where
7575 D: serde::Deserializer<'de>,
7576 {
7577 const FIELDS: &[&str] = &[
7578 "group_deltas",
7579 "groupDeltas",
7580 ];
7581
7582 #[allow(clippy::enum_variant_names)]
7583 enum GeneratedField {
7584 GroupDeltas,
7585 }
7586 impl<'de> serde::Deserialize<'de> for GeneratedField {
7587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7588 where
7589 D: serde::Deserializer<'de>,
7590 {
7591 struct GeneratedVisitor;
7592
7593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7594 type Value = GeneratedField;
7595
7596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7597 write!(formatter, "expected one of: {:?}", &FIELDS)
7598 }
7599
7600 #[allow(unused_variables)]
7601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7602 where
7603 E: serde::de::Error,
7604 {
7605 match value {
7606 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
7607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7608 }
7609 }
7610 }
7611 deserializer.deserialize_identifier(GeneratedVisitor)
7612 }
7613 }
7614 struct GeneratedVisitor;
7615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7616 type Value = hummock_version_delta::GroupDeltas;
7617
7618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7619 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
7620 }
7621
7622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
7623 where
7624 V: serde::de::MapAccess<'de>,
7625 {
7626 let mut group_deltas__ = None;
7627 while let Some(k) = map_.next_key()? {
7628 match k {
7629 GeneratedField::GroupDeltas => {
7630 if group_deltas__.is_some() {
7631 return Err(serde::de::Error::duplicate_field("groupDeltas"));
7632 }
7633 group_deltas__ = Some(map_.next_value()?);
7634 }
7635 }
7636 }
7637 Ok(hummock_version_delta::GroupDeltas {
7638 group_deltas: group_deltas__.unwrap_or_default(),
7639 })
7640 }
7641 }
7642 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
7643 }
7644}
7645impl serde::Serialize for HummockVersionDeltas {
7646 #[allow(deprecated)]
7647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7648 where
7649 S: serde::Serializer,
7650 {
7651 use serde::ser::SerializeStruct;
7652 let mut len = 0;
7653 if !self.version_deltas.is_empty() {
7654 len += 1;
7655 }
7656 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
7657 if !self.version_deltas.is_empty() {
7658 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
7659 }
7660 struct_ser.end()
7661 }
7662}
7663impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
7664 #[allow(deprecated)]
7665 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7666 where
7667 D: serde::Deserializer<'de>,
7668 {
7669 const FIELDS: &[&str] = &[
7670 "version_deltas",
7671 "versionDeltas",
7672 ];
7673
7674 #[allow(clippy::enum_variant_names)]
7675 enum GeneratedField {
7676 VersionDeltas,
7677 }
7678 impl<'de> serde::Deserialize<'de> for GeneratedField {
7679 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7680 where
7681 D: serde::Deserializer<'de>,
7682 {
7683 struct GeneratedVisitor;
7684
7685 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7686 type Value = GeneratedField;
7687
7688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7689 write!(formatter, "expected one of: {:?}", &FIELDS)
7690 }
7691
7692 #[allow(unused_variables)]
7693 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7694 where
7695 E: serde::de::Error,
7696 {
7697 match value {
7698 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
7699 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7700 }
7701 }
7702 }
7703 deserializer.deserialize_identifier(GeneratedVisitor)
7704 }
7705 }
7706 struct GeneratedVisitor;
7707 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7708 type Value = HummockVersionDeltas;
7709
7710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7711 formatter.write_str("struct hummock.HummockVersionDeltas")
7712 }
7713
7714 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
7715 where
7716 V: serde::de::MapAccess<'de>,
7717 {
7718 let mut version_deltas__ = None;
7719 while let Some(k) = map_.next_key()? {
7720 match k {
7721 GeneratedField::VersionDeltas => {
7722 if version_deltas__.is_some() {
7723 return Err(serde::de::Error::duplicate_field("versionDeltas"));
7724 }
7725 version_deltas__ = Some(map_.next_value()?);
7726 }
7727 }
7728 }
7729 Ok(HummockVersionDeltas {
7730 version_deltas: version_deltas__.unwrap_or_default(),
7731 })
7732 }
7733 }
7734 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
7735 }
7736}
7737impl serde::Serialize for HummockVersionStats {
7738 #[allow(deprecated)]
7739 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7740 where
7741 S: serde::Serializer,
7742 {
7743 use serde::ser::SerializeStruct;
7744 let mut len = 0;
7745 if self.hummock_version_id != 0 {
7746 len += 1;
7747 }
7748 if !self.table_stats.is_empty() {
7749 len += 1;
7750 }
7751 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
7752 if self.hummock_version_id != 0 {
7753 #[allow(clippy::needless_borrow)]
7754 #[allow(clippy::needless_borrows_for_generic_args)]
7755 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
7756 }
7757 if !self.table_stats.is_empty() {
7758 struct_ser.serialize_field("tableStats", &self.table_stats)?;
7759 }
7760 struct_ser.end()
7761 }
7762}
7763impl<'de> serde::Deserialize<'de> for HummockVersionStats {
7764 #[allow(deprecated)]
7765 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7766 where
7767 D: serde::Deserializer<'de>,
7768 {
7769 const FIELDS: &[&str] = &[
7770 "hummock_version_id",
7771 "hummockVersionId",
7772 "table_stats",
7773 "tableStats",
7774 ];
7775
7776 #[allow(clippy::enum_variant_names)]
7777 enum GeneratedField {
7778 HummockVersionId,
7779 TableStats,
7780 }
7781 impl<'de> serde::Deserialize<'de> for GeneratedField {
7782 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7783 where
7784 D: serde::Deserializer<'de>,
7785 {
7786 struct GeneratedVisitor;
7787
7788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7789 type Value = GeneratedField;
7790
7791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7792 write!(formatter, "expected one of: {:?}", &FIELDS)
7793 }
7794
7795 #[allow(unused_variables)]
7796 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7797 where
7798 E: serde::de::Error,
7799 {
7800 match value {
7801 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
7802 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
7803 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7804 }
7805 }
7806 }
7807 deserializer.deserialize_identifier(GeneratedVisitor)
7808 }
7809 }
7810 struct GeneratedVisitor;
7811 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7812 type Value = HummockVersionStats;
7813
7814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7815 formatter.write_str("struct hummock.HummockVersionStats")
7816 }
7817
7818 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
7819 where
7820 V: serde::de::MapAccess<'de>,
7821 {
7822 let mut hummock_version_id__ = None;
7823 let mut table_stats__ = None;
7824 while let Some(k) = map_.next_key()? {
7825 match k {
7826 GeneratedField::HummockVersionId => {
7827 if hummock_version_id__.is_some() {
7828 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
7829 }
7830 hummock_version_id__ =
7831 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7832 ;
7833 }
7834 GeneratedField::TableStats => {
7835 if table_stats__.is_some() {
7836 return Err(serde::de::Error::duplicate_field("tableStats"));
7837 }
7838 table_stats__ = Some(
7839 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7840 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7841 );
7842 }
7843 }
7844 }
7845 Ok(HummockVersionStats {
7846 hummock_version_id: hummock_version_id__.unwrap_or_default(),
7847 table_stats: table_stats__.unwrap_or_default(),
7848 })
7849 }
7850 }
7851 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
7852 }
7853}
7854impl serde::Serialize for InitMetadataForReplayRequest {
7855 #[allow(deprecated)]
7856 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7857 where
7858 S: serde::Serializer,
7859 {
7860 use serde::ser::SerializeStruct;
7861 let mut len = 0;
7862 if !self.tables.is_empty() {
7863 len += 1;
7864 }
7865 if !self.compaction_groups.is_empty() {
7866 len += 1;
7867 }
7868 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
7869 if !self.tables.is_empty() {
7870 struct_ser.serialize_field("tables", &self.tables)?;
7871 }
7872 if !self.compaction_groups.is_empty() {
7873 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
7874 }
7875 struct_ser.end()
7876 }
7877}
7878impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
7879 #[allow(deprecated)]
7880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7881 where
7882 D: serde::Deserializer<'de>,
7883 {
7884 const FIELDS: &[&str] = &[
7885 "tables",
7886 "compaction_groups",
7887 "compactionGroups",
7888 ];
7889
7890 #[allow(clippy::enum_variant_names)]
7891 enum GeneratedField {
7892 Tables,
7893 CompactionGroups,
7894 }
7895 impl<'de> serde::Deserialize<'de> for GeneratedField {
7896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7897 where
7898 D: serde::Deserializer<'de>,
7899 {
7900 struct GeneratedVisitor;
7901
7902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7903 type Value = GeneratedField;
7904
7905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7906 write!(formatter, "expected one of: {:?}", &FIELDS)
7907 }
7908
7909 #[allow(unused_variables)]
7910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7911 where
7912 E: serde::de::Error,
7913 {
7914 match value {
7915 "tables" => Ok(GeneratedField::Tables),
7916 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
7917 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7918 }
7919 }
7920 }
7921 deserializer.deserialize_identifier(GeneratedVisitor)
7922 }
7923 }
7924 struct GeneratedVisitor;
7925 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7926 type Value = InitMetadataForReplayRequest;
7927
7928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7929 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
7930 }
7931
7932 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
7933 where
7934 V: serde::de::MapAccess<'de>,
7935 {
7936 let mut tables__ = None;
7937 let mut compaction_groups__ = None;
7938 while let Some(k) = map_.next_key()? {
7939 match k {
7940 GeneratedField::Tables => {
7941 if tables__.is_some() {
7942 return Err(serde::de::Error::duplicate_field("tables"));
7943 }
7944 tables__ = Some(map_.next_value()?);
7945 }
7946 GeneratedField::CompactionGroups => {
7947 if compaction_groups__.is_some() {
7948 return Err(serde::de::Error::duplicate_field("compactionGroups"));
7949 }
7950 compaction_groups__ = Some(map_.next_value()?);
7951 }
7952 }
7953 }
7954 Ok(InitMetadataForReplayRequest {
7955 tables: tables__.unwrap_or_default(),
7956 compaction_groups: compaction_groups__.unwrap_or_default(),
7957 })
7958 }
7959 }
7960 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
7961 }
7962}
7963impl serde::Serialize for InitMetadataForReplayResponse {
7964 #[allow(deprecated)]
7965 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7966 where
7967 S: serde::Serializer,
7968 {
7969 use serde::ser::SerializeStruct;
7970 let len = 0;
7971 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
7972 struct_ser.end()
7973 }
7974}
7975impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
7976 #[allow(deprecated)]
7977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7978 where
7979 D: serde::Deserializer<'de>,
7980 {
7981 const FIELDS: &[&str] = &[
7982 ];
7983
7984 #[allow(clippy::enum_variant_names)]
7985 enum GeneratedField {
7986 }
7987 impl<'de> serde::Deserialize<'de> for GeneratedField {
7988 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7989 where
7990 D: serde::Deserializer<'de>,
7991 {
7992 struct GeneratedVisitor;
7993
7994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7995 type Value = GeneratedField;
7996
7997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7998 write!(formatter, "expected one of: {:?}", &FIELDS)
7999 }
8000
8001 #[allow(unused_variables)]
8002 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8003 where
8004 E: serde::de::Error,
8005 {
8006 Err(serde::de::Error::unknown_field(value, FIELDS))
8007 }
8008 }
8009 deserializer.deserialize_identifier(GeneratedVisitor)
8010 }
8011 }
8012 struct GeneratedVisitor;
8013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8014 type Value = InitMetadataForReplayResponse;
8015
8016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8017 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
8018 }
8019
8020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
8021 where
8022 V: serde::de::MapAccess<'de>,
8023 {
8024 while map_.next_key::<GeneratedField>()?.is_some() {
8025 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8026 }
8027 Ok(InitMetadataForReplayResponse {
8028 })
8029 }
8030 }
8031 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
8032 }
8033}
8034impl serde::Serialize for InputLevel {
8035 #[allow(deprecated)]
8036 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8037 where
8038 S: serde::Serializer,
8039 {
8040 use serde::ser::SerializeStruct;
8041 let mut len = 0;
8042 if self.level_idx != 0 {
8043 len += 1;
8044 }
8045 if self.level_type != 0 {
8046 len += 1;
8047 }
8048 if !self.table_infos.is_empty() {
8049 len += 1;
8050 }
8051 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
8052 if self.level_idx != 0 {
8053 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8054 }
8055 if self.level_type != 0 {
8056 let v = LevelType::try_from(self.level_type)
8057 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
8058 struct_ser.serialize_field("levelType", &v)?;
8059 }
8060 if !self.table_infos.is_empty() {
8061 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
8062 }
8063 struct_ser.end()
8064 }
8065}
8066impl<'de> serde::Deserialize<'de> for InputLevel {
8067 #[allow(deprecated)]
8068 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8069 where
8070 D: serde::Deserializer<'de>,
8071 {
8072 const FIELDS: &[&str] = &[
8073 "level_idx",
8074 "levelIdx",
8075 "level_type",
8076 "levelType",
8077 "table_infos",
8078 "tableInfos",
8079 ];
8080
8081 #[allow(clippy::enum_variant_names)]
8082 enum GeneratedField {
8083 LevelIdx,
8084 LevelType,
8085 TableInfos,
8086 }
8087 impl<'de> serde::Deserialize<'de> for GeneratedField {
8088 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8089 where
8090 D: serde::Deserializer<'de>,
8091 {
8092 struct GeneratedVisitor;
8093
8094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8095 type Value = GeneratedField;
8096
8097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8098 write!(formatter, "expected one of: {:?}", &FIELDS)
8099 }
8100
8101 #[allow(unused_variables)]
8102 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8103 where
8104 E: serde::de::Error,
8105 {
8106 match value {
8107 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8108 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8109 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8110 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8111 }
8112 }
8113 }
8114 deserializer.deserialize_identifier(GeneratedVisitor)
8115 }
8116 }
8117 struct GeneratedVisitor;
8118 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8119 type Value = InputLevel;
8120
8121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8122 formatter.write_str("struct hummock.InputLevel")
8123 }
8124
8125 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
8126 where
8127 V: serde::de::MapAccess<'de>,
8128 {
8129 let mut level_idx__ = None;
8130 let mut level_type__ = None;
8131 let mut table_infos__ = None;
8132 while let Some(k) = map_.next_key()? {
8133 match k {
8134 GeneratedField::LevelIdx => {
8135 if level_idx__.is_some() {
8136 return Err(serde::de::Error::duplicate_field("levelIdx"));
8137 }
8138 level_idx__ =
8139 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8140 ;
8141 }
8142 GeneratedField::LevelType => {
8143 if level_type__.is_some() {
8144 return Err(serde::de::Error::duplicate_field("levelType"));
8145 }
8146 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8147 }
8148 GeneratedField::TableInfos => {
8149 if table_infos__.is_some() {
8150 return Err(serde::de::Error::duplicate_field("tableInfos"));
8151 }
8152 table_infos__ = Some(map_.next_value()?);
8153 }
8154 }
8155 }
8156 Ok(InputLevel {
8157 level_idx: level_idx__.unwrap_or_default(),
8158 level_type: level_type__.unwrap_or_default(),
8159 table_infos: table_infos__.unwrap_or_default(),
8160 })
8161 }
8162 }
8163 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
8164 }
8165}
8166impl serde::Serialize for IntraLevelDelta {
8167 #[allow(deprecated)]
8168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8169 where
8170 S: serde::Serializer,
8171 {
8172 use serde::ser::SerializeStruct;
8173 let mut len = 0;
8174 if self.level_idx != 0 {
8175 len += 1;
8176 }
8177 if self.l0_sub_level_id != 0 {
8178 len += 1;
8179 }
8180 if !self.removed_table_ids.is_empty() {
8181 len += 1;
8182 }
8183 if !self.inserted_table_infos.is_empty() {
8184 len += 1;
8185 }
8186 if self.vnode_partition_count != 0 {
8187 len += 1;
8188 }
8189 if self.compaction_group_version_id != 0 {
8190 len += 1;
8191 }
8192 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
8193 if self.level_idx != 0 {
8194 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8195 }
8196 if self.l0_sub_level_id != 0 {
8197 #[allow(clippy::needless_borrow)]
8198 #[allow(clippy::needless_borrows_for_generic_args)]
8199 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
8200 }
8201 if !self.removed_table_ids.is_empty() {
8202 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8203 }
8204 if !self.inserted_table_infos.is_empty() {
8205 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
8206 }
8207 if self.vnode_partition_count != 0 {
8208 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8209 }
8210 if self.compaction_group_version_id != 0 {
8211 #[allow(clippy::needless_borrow)]
8212 #[allow(clippy::needless_borrows_for_generic_args)]
8213 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
8214 }
8215 struct_ser.end()
8216 }
8217}
8218impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
8219 #[allow(deprecated)]
8220 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8221 where
8222 D: serde::Deserializer<'de>,
8223 {
8224 const FIELDS: &[&str] = &[
8225 "level_idx",
8226 "levelIdx",
8227 "l0_sub_level_id",
8228 "l0SubLevelId",
8229 "removed_table_ids",
8230 "removedTableIds",
8231 "inserted_table_infos",
8232 "insertedTableInfos",
8233 "vnode_partition_count",
8234 "vnodePartitionCount",
8235 "compaction_group_version_id",
8236 "compactionGroupVersionId",
8237 ];
8238
8239 #[allow(clippy::enum_variant_names)]
8240 enum GeneratedField {
8241 LevelIdx,
8242 L0SubLevelId,
8243 RemovedTableIds,
8244 InsertedTableInfos,
8245 VnodePartitionCount,
8246 CompactionGroupVersionId,
8247 }
8248 impl<'de> serde::Deserialize<'de> for GeneratedField {
8249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8250 where
8251 D: serde::Deserializer<'de>,
8252 {
8253 struct GeneratedVisitor;
8254
8255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8256 type Value = GeneratedField;
8257
8258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8259 write!(formatter, "expected one of: {:?}", &FIELDS)
8260 }
8261
8262 #[allow(unused_variables)]
8263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8264 where
8265 E: serde::de::Error,
8266 {
8267 match value {
8268 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8269 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
8270 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
8271 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
8272 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8273 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
8274 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8275 }
8276 }
8277 }
8278 deserializer.deserialize_identifier(GeneratedVisitor)
8279 }
8280 }
8281 struct GeneratedVisitor;
8282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8283 type Value = IntraLevelDelta;
8284
8285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8286 formatter.write_str("struct hummock.IntraLevelDelta")
8287 }
8288
8289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
8290 where
8291 V: serde::de::MapAccess<'de>,
8292 {
8293 let mut level_idx__ = None;
8294 let mut l0_sub_level_id__ = None;
8295 let mut removed_table_ids__ = None;
8296 let mut inserted_table_infos__ = None;
8297 let mut vnode_partition_count__ = None;
8298 let mut compaction_group_version_id__ = None;
8299 while let Some(k) = map_.next_key()? {
8300 match k {
8301 GeneratedField::LevelIdx => {
8302 if level_idx__.is_some() {
8303 return Err(serde::de::Error::duplicate_field("levelIdx"));
8304 }
8305 level_idx__ =
8306 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8307 ;
8308 }
8309 GeneratedField::L0SubLevelId => {
8310 if l0_sub_level_id__.is_some() {
8311 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
8312 }
8313 l0_sub_level_id__ =
8314 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8315 ;
8316 }
8317 GeneratedField::RemovedTableIds => {
8318 if removed_table_ids__.is_some() {
8319 return Err(serde::de::Error::duplicate_field("removedTableIds"));
8320 }
8321 removed_table_ids__ =
8322 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8323 .into_iter().map(|x| x.0).collect())
8324 ;
8325 }
8326 GeneratedField::InsertedTableInfos => {
8327 if inserted_table_infos__.is_some() {
8328 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
8329 }
8330 inserted_table_infos__ = Some(map_.next_value()?);
8331 }
8332 GeneratedField::VnodePartitionCount => {
8333 if vnode_partition_count__.is_some() {
8334 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
8335 }
8336 vnode_partition_count__ =
8337 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8338 ;
8339 }
8340 GeneratedField::CompactionGroupVersionId => {
8341 if compaction_group_version_id__.is_some() {
8342 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
8343 }
8344 compaction_group_version_id__ =
8345 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8346 ;
8347 }
8348 }
8349 }
8350 Ok(IntraLevelDelta {
8351 level_idx: level_idx__.unwrap_or_default(),
8352 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
8353 removed_table_ids: removed_table_ids__.unwrap_or_default(),
8354 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
8355 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
8356 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
8357 })
8358 }
8359 }
8360 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
8361 }
8362}
8363impl serde::Serialize for KeyRange {
8364 #[allow(deprecated)]
8365 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8366 where
8367 S: serde::Serializer,
8368 {
8369 use serde::ser::SerializeStruct;
8370 let mut len = 0;
8371 if !self.left.is_empty() {
8372 len += 1;
8373 }
8374 if !self.right.is_empty() {
8375 len += 1;
8376 }
8377 if self.right_exclusive {
8378 len += 1;
8379 }
8380 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
8381 if !self.left.is_empty() {
8382 #[allow(clippy::needless_borrow)]
8383 #[allow(clippy::needless_borrows_for_generic_args)]
8384 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
8385 }
8386 if !self.right.is_empty() {
8387 #[allow(clippy::needless_borrow)]
8388 #[allow(clippy::needless_borrows_for_generic_args)]
8389 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
8390 }
8391 if self.right_exclusive {
8392 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
8393 }
8394 struct_ser.end()
8395 }
8396}
8397impl<'de> serde::Deserialize<'de> for KeyRange {
8398 #[allow(deprecated)]
8399 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8400 where
8401 D: serde::Deserializer<'de>,
8402 {
8403 const FIELDS: &[&str] = &[
8404 "left",
8405 "right",
8406 "right_exclusive",
8407 "rightExclusive",
8408 ];
8409
8410 #[allow(clippy::enum_variant_names)]
8411 enum GeneratedField {
8412 Left,
8413 Right,
8414 RightExclusive,
8415 }
8416 impl<'de> serde::Deserialize<'de> for GeneratedField {
8417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8418 where
8419 D: serde::Deserializer<'de>,
8420 {
8421 struct GeneratedVisitor;
8422
8423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8424 type Value = GeneratedField;
8425
8426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8427 write!(formatter, "expected one of: {:?}", &FIELDS)
8428 }
8429
8430 #[allow(unused_variables)]
8431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8432 where
8433 E: serde::de::Error,
8434 {
8435 match value {
8436 "left" => Ok(GeneratedField::Left),
8437 "right" => Ok(GeneratedField::Right),
8438 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
8439 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8440 }
8441 }
8442 }
8443 deserializer.deserialize_identifier(GeneratedVisitor)
8444 }
8445 }
8446 struct GeneratedVisitor;
8447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8448 type Value = KeyRange;
8449
8450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8451 formatter.write_str("struct hummock.KeyRange")
8452 }
8453
8454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
8455 where
8456 V: serde::de::MapAccess<'de>,
8457 {
8458 let mut left__ = None;
8459 let mut right__ = None;
8460 let mut right_exclusive__ = None;
8461 while let Some(k) = map_.next_key()? {
8462 match k {
8463 GeneratedField::Left => {
8464 if left__.is_some() {
8465 return Err(serde::de::Error::duplicate_field("left"));
8466 }
8467 left__ =
8468 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
8469 ;
8470 }
8471 GeneratedField::Right => {
8472 if right__.is_some() {
8473 return Err(serde::de::Error::duplicate_field("right"));
8474 }
8475 right__ =
8476 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
8477 ;
8478 }
8479 GeneratedField::RightExclusive => {
8480 if right_exclusive__.is_some() {
8481 return Err(serde::de::Error::duplicate_field("rightExclusive"));
8482 }
8483 right_exclusive__ = Some(map_.next_value()?);
8484 }
8485 }
8486 }
8487 Ok(KeyRange {
8488 left: left__.unwrap_or_default(),
8489 right: right__.unwrap_or_default(),
8490 right_exclusive: right_exclusive__.unwrap_or_default(),
8491 })
8492 }
8493 }
8494 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
8495 }
8496}
8497impl serde::Serialize for Level {
8498 #[allow(deprecated)]
8499 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8500 where
8501 S: serde::Serializer,
8502 {
8503 use serde::ser::SerializeStruct;
8504 let mut len = 0;
8505 if self.level_idx != 0 {
8506 len += 1;
8507 }
8508 if self.level_type != 0 {
8509 len += 1;
8510 }
8511 if !self.table_infos.is_empty() {
8512 len += 1;
8513 }
8514 if self.total_file_size != 0 {
8515 len += 1;
8516 }
8517 if self.sub_level_id != 0 {
8518 len += 1;
8519 }
8520 if self.uncompressed_file_size != 0 {
8521 len += 1;
8522 }
8523 if self.vnode_partition_count != 0 {
8524 len += 1;
8525 }
8526 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
8527 if self.level_idx != 0 {
8528 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8529 }
8530 if self.level_type != 0 {
8531 let v = LevelType::try_from(self.level_type)
8532 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
8533 struct_ser.serialize_field("levelType", &v)?;
8534 }
8535 if !self.table_infos.is_empty() {
8536 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
8537 }
8538 if self.total_file_size != 0 {
8539 #[allow(clippy::needless_borrow)]
8540 #[allow(clippy::needless_borrows_for_generic_args)]
8541 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8542 }
8543 if self.sub_level_id != 0 {
8544 #[allow(clippy::needless_borrow)]
8545 #[allow(clippy::needless_borrows_for_generic_args)]
8546 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
8547 }
8548 if self.uncompressed_file_size != 0 {
8549 #[allow(clippy::needless_borrow)]
8550 #[allow(clippy::needless_borrows_for_generic_args)]
8551 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
8552 }
8553 if self.vnode_partition_count != 0 {
8554 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8555 }
8556 struct_ser.end()
8557 }
8558}
8559impl<'de> serde::Deserialize<'de> for Level {
8560 #[allow(deprecated)]
8561 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8562 where
8563 D: serde::Deserializer<'de>,
8564 {
8565 const FIELDS: &[&str] = &[
8566 "level_idx",
8567 "levelIdx",
8568 "level_type",
8569 "levelType",
8570 "table_infos",
8571 "tableInfos",
8572 "total_file_size",
8573 "totalFileSize",
8574 "sub_level_id",
8575 "subLevelId",
8576 "uncompressed_file_size",
8577 "uncompressedFileSize",
8578 "vnode_partition_count",
8579 "vnodePartitionCount",
8580 ];
8581
8582 #[allow(clippy::enum_variant_names)]
8583 enum GeneratedField {
8584 LevelIdx,
8585 LevelType,
8586 TableInfos,
8587 TotalFileSize,
8588 SubLevelId,
8589 UncompressedFileSize,
8590 VnodePartitionCount,
8591 }
8592 impl<'de> serde::Deserialize<'de> for GeneratedField {
8593 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8594 where
8595 D: serde::Deserializer<'de>,
8596 {
8597 struct GeneratedVisitor;
8598
8599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8600 type Value = GeneratedField;
8601
8602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8603 write!(formatter, "expected one of: {:?}", &FIELDS)
8604 }
8605
8606 #[allow(unused_variables)]
8607 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8608 where
8609 E: serde::de::Error,
8610 {
8611 match value {
8612 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8613 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8614 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8615 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8616 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
8617 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
8618 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8619 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8620 }
8621 }
8622 }
8623 deserializer.deserialize_identifier(GeneratedVisitor)
8624 }
8625 }
8626 struct GeneratedVisitor;
8627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8628 type Value = Level;
8629
8630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8631 formatter.write_str("struct hummock.Level")
8632 }
8633
8634 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
8635 where
8636 V: serde::de::MapAccess<'de>,
8637 {
8638 let mut level_idx__ = None;
8639 let mut level_type__ = None;
8640 let mut table_infos__ = None;
8641 let mut total_file_size__ = None;
8642 let mut sub_level_id__ = None;
8643 let mut uncompressed_file_size__ = None;
8644 let mut vnode_partition_count__ = None;
8645 while let Some(k) = map_.next_key()? {
8646 match k {
8647 GeneratedField::LevelIdx => {
8648 if level_idx__.is_some() {
8649 return Err(serde::de::Error::duplicate_field("levelIdx"));
8650 }
8651 level_idx__ =
8652 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8653 ;
8654 }
8655 GeneratedField::LevelType => {
8656 if level_type__.is_some() {
8657 return Err(serde::de::Error::duplicate_field("levelType"));
8658 }
8659 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8660 }
8661 GeneratedField::TableInfos => {
8662 if table_infos__.is_some() {
8663 return Err(serde::de::Error::duplicate_field("tableInfos"));
8664 }
8665 table_infos__ = Some(map_.next_value()?);
8666 }
8667 GeneratedField::TotalFileSize => {
8668 if total_file_size__.is_some() {
8669 return Err(serde::de::Error::duplicate_field("totalFileSize"));
8670 }
8671 total_file_size__ =
8672 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8673 ;
8674 }
8675 GeneratedField::SubLevelId => {
8676 if sub_level_id__.is_some() {
8677 return Err(serde::de::Error::duplicate_field("subLevelId"));
8678 }
8679 sub_level_id__ =
8680 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8681 ;
8682 }
8683 GeneratedField::UncompressedFileSize => {
8684 if uncompressed_file_size__.is_some() {
8685 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
8686 }
8687 uncompressed_file_size__ =
8688 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8689 ;
8690 }
8691 GeneratedField::VnodePartitionCount => {
8692 if vnode_partition_count__.is_some() {
8693 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
8694 }
8695 vnode_partition_count__ =
8696 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8697 ;
8698 }
8699 }
8700 }
8701 Ok(Level {
8702 level_idx: level_idx__.unwrap_or_default(),
8703 level_type: level_type__.unwrap_or_default(),
8704 table_infos: table_infos__.unwrap_or_default(),
8705 total_file_size: total_file_size__.unwrap_or_default(),
8706 sub_level_id: sub_level_id__.unwrap_or_default(),
8707 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
8708 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
8709 })
8710 }
8711 }
8712 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
8713 }
8714}
8715impl serde::Serialize for LevelHandler {
8716 #[allow(deprecated)]
8717 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8718 where
8719 S: serde::Serializer,
8720 {
8721 use serde::ser::SerializeStruct;
8722 let mut len = 0;
8723 if self.level != 0 {
8724 len += 1;
8725 }
8726 if !self.tasks.is_empty() {
8727 len += 1;
8728 }
8729 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
8730 if self.level != 0 {
8731 struct_ser.serialize_field("level", &self.level)?;
8732 }
8733 if !self.tasks.is_empty() {
8734 struct_ser.serialize_field("tasks", &self.tasks)?;
8735 }
8736 struct_ser.end()
8737 }
8738}
8739impl<'de> serde::Deserialize<'de> for LevelHandler {
8740 #[allow(deprecated)]
8741 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8742 where
8743 D: serde::Deserializer<'de>,
8744 {
8745 const FIELDS: &[&str] = &[
8746 "level",
8747 "tasks",
8748 ];
8749
8750 #[allow(clippy::enum_variant_names)]
8751 enum GeneratedField {
8752 Level,
8753 Tasks,
8754 }
8755 impl<'de> serde::Deserialize<'de> for GeneratedField {
8756 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8757 where
8758 D: serde::Deserializer<'de>,
8759 {
8760 struct GeneratedVisitor;
8761
8762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8763 type Value = GeneratedField;
8764
8765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8766 write!(formatter, "expected one of: {:?}", &FIELDS)
8767 }
8768
8769 #[allow(unused_variables)]
8770 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8771 where
8772 E: serde::de::Error,
8773 {
8774 match value {
8775 "level" => Ok(GeneratedField::Level),
8776 "tasks" => Ok(GeneratedField::Tasks),
8777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8778 }
8779 }
8780 }
8781 deserializer.deserialize_identifier(GeneratedVisitor)
8782 }
8783 }
8784 struct GeneratedVisitor;
8785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8786 type Value = LevelHandler;
8787
8788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8789 formatter.write_str("struct hummock.LevelHandler")
8790 }
8791
8792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
8793 where
8794 V: serde::de::MapAccess<'de>,
8795 {
8796 let mut level__ = None;
8797 let mut tasks__ = None;
8798 while let Some(k) = map_.next_key()? {
8799 match k {
8800 GeneratedField::Level => {
8801 if level__.is_some() {
8802 return Err(serde::de::Error::duplicate_field("level"));
8803 }
8804 level__ =
8805 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8806 ;
8807 }
8808 GeneratedField::Tasks => {
8809 if tasks__.is_some() {
8810 return Err(serde::de::Error::duplicate_field("tasks"));
8811 }
8812 tasks__ = Some(map_.next_value()?);
8813 }
8814 }
8815 }
8816 Ok(LevelHandler {
8817 level: level__.unwrap_or_default(),
8818 tasks: tasks__.unwrap_or_default(),
8819 })
8820 }
8821 }
8822 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
8823 }
8824}
8825impl serde::Serialize for level_handler::RunningCompactTask {
8826 #[allow(deprecated)]
8827 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8828 where
8829 S: serde::Serializer,
8830 {
8831 use serde::ser::SerializeStruct;
8832 let mut len = 0;
8833 if self.task_id != 0 {
8834 len += 1;
8835 }
8836 if !self.ssts.is_empty() {
8837 len += 1;
8838 }
8839 if self.total_file_size != 0 {
8840 len += 1;
8841 }
8842 if self.target_level != 0 {
8843 len += 1;
8844 }
8845 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
8846 if self.task_id != 0 {
8847 #[allow(clippy::needless_borrow)]
8848 #[allow(clippy::needless_borrows_for_generic_args)]
8849 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
8850 }
8851 if !self.ssts.is_empty() {
8852 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8853 }
8854 if self.total_file_size != 0 {
8855 #[allow(clippy::needless_borrow)]
8856 #[allow(clippy::needless_borrows_for_generic_args)]
8857 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8858 }
8859 if self.target_level != 0 {
8860 struct_ser.serialize_field("targetLevel", &self.target_level)?;
8861 }
8862 struct_ser.end()
8863 }
8864}
8865impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
8866 #[allow(deprecated)]
8867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8868 where
8869 D: serde::Deserializer<'de>,
8870 {
8871 const FIELDS: &[&str] = &[
8872 "task_id",
8873 "taskId",
8874 "ssts",
8875 "total_file_size",
8876 "totalFileSize",
8877 "target_level",
8878 "targetLevel",
8879 ];
8880
8881 #[allow(clippy::enum_variant_names)]
8882 enum GeneratedField {
8883 TaskId,
8884 Ssts,
8885 TotalFileSize,
8886 TargetLevel,
8887 }
8888 impl<'de> serde::Deserialize<'de> for GeneratedField {
8889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8890 where
8891 D: serde::Deserializer<'de>,
8892 {
8893 struct GeneratedVisitor;
8894
8895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8896 type Value = GeneratedField;
8897
8898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8899 write!(formatter, "expected one of: {:?}", &FIELDS)
8900 }
8901
8902 #[allow(unused_variables)]
8903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8904 where
8905 E: serde::de::Error,
8906 {
8907 match value {
8908 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8909 "ssts" => Ok(GeneratedField::Ssts),
8910 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8911 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
8912 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8913 }
8914 }
8915 }
8916 deserializer.deserialize_identifier(GeneratedVisitor)
8917 }
8918 }
8919 struct GeneratedVisitor;
8920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8921 type Value = level_handler::RunningCompactTask;
8922
8923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8924 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
8925 }
8926
8927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
8928 where
8929 V: serde::de::MapAccess<'de>,
8930 {
8931 let mut task_id__ = None;
8932 let mut ssts__ = None;
8933 let mut total_file_size__ = None;
8934 let mut target_level__ = None;
8935 while let Some(k) = map_.next_key()? {
8936 match k {
8937 GeneratedField::TaskId => {
8938 if task_id__.is_some() {
8939 return Err(serde::de::Error::duplicate_field("taskId"));
8940 }
8941 task_id__ =
8942 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8943 ;
8944 }
8945 GeneratedField::Ssts => {
8946 if ssts__.is_some() {
8947 return Err(serde::de::Error::duplicate_field("ssts"));
8948 }
8949 ssts__ =
8950 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8951 .into_iter().map(|x| x.0).collect())
8952 ;
8953 }
8954 GeneratedField::TotalFileSize => {
8955 if total_file_size__.is_some() {
8956 return Err(serde::de::Error::duplicate_field("totalFileSize"));
8957 }
8958 total_file_size__ =
8959 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8960 ;
8961 }
8962 GeneratedField::TargetLevel => {
8963 if target_level__.is_some() {
8964 return Err(serde::de::Error::duplicate_field("targetLevel"));
8965 }
8966 target_level__ =
8967 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8968 ;
8969 }
8970 }
8971 }
8972 Ok(level_handler::RunningCompactTask {
8973 task_id: task_id__.unwrap_or_default(),
8974 ssts: ssts__.unwrap_or_default(),
8975 total_file_size: total_file_size__.unwrap_or_default(),
8976 target_level: target_level__.unwrap_or_default(),
8977 })
8978 }
8979 }
8980 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
8981 }
8982}
8983impl serde::Serialize for LevelType {
8984 #[allow(deprecated)]
8985 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8986 where
8987 S: serde::Serializer,
8988 {
8989 let variant = match self {
8990 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
8991 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
8992 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
8993 };
8994 serializer.serialize_str(variant)
8995 }
8996}
8997impl<'de> serde::Deserialize<'de> for LevelType {
8998 #[allow(deprecated)]
8999 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9000 where
9001 D: serde::Deserializer<'de>,
9002 {
9003 const FIELDS: &[&str] = &[
9004 "LEVEL_TYPE_UNSPECIFIED",
9005 "LEVEL_TYPE_NONOVERLAPPING",
9006 "LEVEL_TYPE_OVERLAPPING",
9007 ];
9008
9009 struct GeneratedVisitor;
9010
9011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9012 type Value = LevelType;
9013
9014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9015 write!(formatter, "expected one of: {:?}", &FIELDS)
9016 }
9017
9018 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9019 where
9020 E: serde::de::Error,
9021 {
9022 i32::try_from(v)
9023 .ok()
9024 .and_then(|x| x.try_into().ok())
9025 .ok_or_else(|| {
9026 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9027 })
9028 }
9029
9030 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9031 where
9032 E: serde::de::Error,
9033 {
9034 i32::try_from(v)
9035 .ok()
9036 .and_then(|x| x.try_into().ok())
9037 .ok_or_else(|| {
9038 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9039 })
9040 }
9041
9042 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9043 where
9044 E: serde::de::Error,
9045 {
9046 match value {
9047 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
9048 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
9049 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
9050 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9051 }
9052 }
9053 }
9054 deserializer.deserialize_any(GeneratedVisitor)
9055 }
9056}
9057impl serde::Serialize for ListActiveWriteLimitRequest {
9058 #[allow(deprecated)]
9059 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9060 where
9061 S: serde::Serializer,
9062 {
9063 use serde::ser::SerializeStruct;
9064 let len = 0;
9065 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
9066 struct_ser.end()
9067 }
9068}
9069impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
9070 #[allow(deprecated)]
9071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9072 where
9073 D: serde::Deserializer<'de>,
9074 {
9075 const FIELDS: &[&str] = &[
9076 ];
9077
9078 #[allow(clippy::enum_variant_names)]
9079 enum GeneratedField {
9080 }
9081 impl<'de> serde::Deserialize<'de> for GeneratedField {
9082 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9083 where
9084 D: serde::Deserializer<'de>,
9085 {
9086 struct GeneratedVisitor;
9087
9088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9089 type Value = GeneratedField;
9090
9091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9092 write!(formatter, "expected one of: {:?}", &FIELDS)
9093 }
9094
9095 #[allow(unused_variables)]
9096 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9097 where
9098 E: serde::de::Error,
9099 {
9100 Err(serde::de::Error::unknown_field(value, FIELDS))
9101 }
9102 }
9103 deserializer.deserialize_identifier(GeneratedVisitor)
9104 }
9105 }
9106 struct GeneratedVisitor;
9107 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9108 type Value = ListActiveWriteLimitRequest;
9109
9110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9111 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
9112 }
9113
9114 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
9115 where
9116 V: serde::de::MapAccess<'de>,
9117 {
9118 while map_.next_key::<GeneratedField>()?.is_some() {
9119 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9120 }
9121 Ok(ListActiveWriteLimitRequest {
9122 })
9123 }
9124 }
9125 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
9126 }
9127}
9128impl serde::Serialize for ListActiveWriteLimitResponse {
9129 #[allow(deprecated)]
9130 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9131 where
9132 S: serde::Serializer,
9133 {
9134 use serde::ser::SerializeStruct;
9135 let mut len = 0;
9136 if !self.write_limits.is_empty() {
9137 len += 1;
9138 }
9139 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
9140 if !self.write_limits.is_empty() {
9141 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
9142 }
9143 struct_ser.end()
9144 }
9145}
9146impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
9147 #[allow(deprecated)]
9148 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9149 where
9150 D: serde::Deserializer<'de>,
9151 {
9152 const FIELDS: &[&str] = &[
9153 "write_limits",
9154 "writeLimits",
9155 ];
9156
9157 #[allow(clippy::enum_variant_names)]
9158 enum GeneratedField {
9159 WriteLimits,
9160 }
9161 impl<'de> serde::Deserialize<'de> for GeneratedField {
9162 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9163 where
9164 D: serde::Deserializer<'de>,
9165 {
9166 struct GeneratedVisitor;
9167
9168 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9169 type Value = GeneratedField;
9170
9171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9172 write!(formatter, "expected one of: {:?}", &FIELDS)
9173 }
9174
9175 #[allow(unused_variables)]
9176 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9177 where
9178 E: serde::de::Error,
9179 {
9180 match value {
9181 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
9182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9183 }
9184 }
9185 }
9186 deserializer.deserialize_identifier(GeneratedVisitor)
9187 }
9188 }
9189 struct GeneratedVisitor;
9190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9191 type Value = ListActiveWriteLimitResponse;
9192
9193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9194 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
9195 }
9196
9197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
9198 where
9199 V: serde::de::MapAccess<'de>,
9200 {
9201 let mut write_limits__ = None;
9202 while let Some(k) = map_.next_key()? {
9203 match k {
9204 GeneratedField::WriteLimits => {
9205 if write_limits__.is_some() {
9206 return Err(serde::de::Error::duplicate_field("writeLimits"));
9207 }
9208 write_limits__ = Some(
9209 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
9210 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9211 );
9212 }
9213 }
9214 }
9215 Ok(ListActiveWriteLimitResponse {
9216 write_limits: write_limits__.unwrap_or_default(),
9217 })
9218 }
9219 }
9220 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
9221 }
9222}
9223impl serde::Serialize for ListBranchedObjectRequest {
9224 #[allow(deprecated)]
9225 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9226 where
9227 S: serde::Serializer,
9228 {
9229 use serde::ser::SerializeStruct;
9230 let len = 0;
9231 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
9232 struct_ser.end()
9233 }
9234}
9235impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
9236 #[allow(deprecated)]
9237 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9238 where
9239 D: serde::Deserializer<'de>,
9240 {
9241 const FIELDS: &[&str] = &[
9242 ];
9243
9244 #[allow(clippy::enum_variant_names)]
9245 enum GeneratedField {
9246 }
9247 impl<'de> serde::Deserialize<'de> for GeneratedField {
9248 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9249 where
9250 D: serde::Deserializer<'de>,
9251 {
9252 struct GeneratedVisitor;
9253
9254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9255 type Value = GeneratedField;
9256
9257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9258 write!(formatter, "expected one of: {:?}", &FIELDS)
9259 }
9260
9261 #[allow(unused_variables)]
9262 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9263 where
9264 E: serde::de::Error,
9265 {
9266 Err(serde::de::Error::unknown_field(value, FIELDS))
9267 }
9268 }
9269 deserializer.deserialize_identifier(GeneratedVisitor)
9270 }
9271 }
9272 struct GeneratedVisitor;
9273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9274 type Value = ListBranchedObjectRequest;
9275
9276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9277 formatter.write_str("struct hummock.ListBranchedObjectRequest")
9278 }
9279
9280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
9281 where
9282 V: serde::de::MapAccess<'de>,
9283 {
9284 while map_.next_key::<GeneratedField>()?.is_some() {
9285 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9286 }
9287 Ok(ListBranchedObjectRequest {
9288 })
9289 }
9290 }
9291 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
9292 }
9293}
9294impl serde::Serialize for ListBranchedObjectResponse {
9295 #[allow(deprecated)]
9296 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9297 where
9298 S: serde::Serializer,
9299 {
9300 use serde::ser::SerializeStruct;
9301 let mut len = 0;
9302 if !self.branched_objects.is_empty() {
9303 len += 1;
9304 }
9305 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
9306 if !self.branched_objects.is_empty() {
9307 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
9308 }
9309 struct_ser.end()
9310 }
9311}
9312impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
9313 #[allow(deprecated)]
9314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9315 where
9316 D: serde::Deserializer<'de>,
9317 {
9318 const FIELDS: &[&str] = &[
9319 "branched_objects",
9320 "branchedObjects",
9321 ];
9322
9323 #[allow(clippy::enum_variant_names)]
9324 enum GeneratedField {
9325 BranchedObjects,
9326 }
9327 impl<'de> serde::Deserialize<'de> for GeneratedField {
9328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9329 where
9330 D: serde::Deserializer<'de>,
9331 {
9332 struct GeneratedVisitor;
9333
9334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9335 type Value = GeneratedField;
9336
9337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9338 write!(formatter, "expected one of: {:?}", &FIELDS)
9339 }
9340
9341 #[allow(unused_variables)]
9342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9343 where
9344 E: serde::de::Error,
9345 {
9346 match value {
9347 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
9348 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9349 }
9350 }
9351 }
9352 deserializer.deserialize_identifier(GeneratedVisitor)
9353 }
9354 }
9355 struct GeneratedVisitor;
9356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9357 type Value = ListBranchedObjectResponse;
9358
9359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9360 formatter.write_str("struct hummock.ListBranchedObjectResponse")
9361 }
9362
9363 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
9364 where
9365 V: serde::de::MapAccess<'de>,
9366 {
9367 let mut branched_objects__ = None;
9368 while let Some(k) = map_.next_key()? {
9369 match k {
9370 GeneratedField::BranchedObjects => {
9371 if branched_objects__.is_some() {
9372 return Err(serde::de::Error::duplicate_field("branchedObjects"));
9373 }
9374 branched_objects__ = Some(map_.next_value()?);
9375 }
9376 }
9377 }
9378 Ok(ListBranchedObjectResponse {
9379 branched_objects: branched_objects__.unwrap_or_default(),
9380 })
9381 }
9382 }
9383 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
9384 }
9385}
9386impl serde::Serialize for ListCompactTaskAssignmentRequest {
9387 #[allow(deprecated)]
9388 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9389 where
9390 S: serde::Serializer,
9391 {
9392 use serde::ser::SerializeStruct;
9393 let len = 0;
9394 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
9395 struct_ser.end()
9396 }
9397}
9398impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
9399 #[allow(deprecated)]
9400 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9401 where
9402 D: serde::Deserializer<'de>,
9403 {
9404 const FIELDS: &[&str] = &[
9405 ];
9406
9407 #[allow(clippy::enum_variant_names)]
9408 enum GeneratedField {
9409 }
9410 impl<'de> serde::Deserialize<'de> for GeneratedField {
9411 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9412 where
9413 D: serde::Deserializer<'de>,
9414 {
9415 struct GeneratedVisitor;
9416
9417 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9418 type Value = GeneratedField;
9419
9420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9421 write!(formatter, "expected one of: {:?}", &FIELDS)
9422 }
9423
9424 #[allow(unused_variables)]
9425 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9426 where
9427 E: serde::de::Error,
9428 {
9429 Err(serde::de::Error::unknown_field(value, FIELDS))
9430 }
9431 }
9432 deserializer.deserialize_identifier(GeneratedVisitor)
9433 }
9434 }
9435 struct GeneratedVisitor;
9436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9437 type Value = ListCompactTaskAssignmentRequest;
9438
9439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9440 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
9441 }
9442
9443 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
9444 where
9445 V: serde::de::MapAccess<'de>,
9446 {
9447 while map_.next_key::<GeneratedField>()?.is_some() {
9448 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9449 }
9450 Ok(ListCompactTaskAssignmentRequest {
9451 })
9452 }
9453 }
9454 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
9455 }
9456}
9457impl serde::Serialize for ListCompactTaskAssignmentResponse {
9458 #[allow(deprecated)]
9459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9460 where
9461 S: serde::Serializer,
9462 {
9463 use serde::ser::SerializeStruct;
9464 let mut len = 0;
9465 if !self.task_assignment.is_empty() {
9466 len += 1;
9467 }
9468 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
9469 if !self.task_assignment.is_empty() {
9470 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
9471 }
9472 struct_ser.end()
9473 }
9474}
9475impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
9476 #[allow(deprecated)]
9477 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9478 where
9479 D: serde::Deserializer<'de>,
9480 {
9481 const FIELDS: &[&str] = &[
9482 "task_assignment",
9483 "taskAssignment",
9484 ];
9485
9486 #[allow(clippy::enum_variant_names)]
9487 enum GeneratedField {
9488 TaskAssignment,
9489 }
9490 impl<'de> serde::Deserialize<'de> for GeneratedField {
9491 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9492 where
9493 D: serde::Deserializer<'de>,
9494 {
9495 struct GeneratedVisitor;
9496
9497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9498 type Value = GeneratedField;
9499
9500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9501 write!(formatter, "expected one of: {:?}", &FIELDS)
9502 }
9503
9504 #[allow(unused_variables)]
9505 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9506 where
9507 E: serde::de::Error,
9508 {
9509 match value {
9510 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
9511 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9512 }
9513 }
9514 }
9515 deserializer.deserialize_identifier(GeneratedVisitor)
9516 }
9517 }
9518 struct GeneratedVisitor;
9519 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9520 type Value = ListCompactTaskAssignmentResponse;
9521
9522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9523 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
9524 }
9525
9526 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
9527 where
9528 V: serde::de::MapAccess<'de>,
9529 {
9530 let mut task_assignment__ = None;
9531 while let Some(k) = map_.next_key()? {
9532 match k {
9533 GeneratedField::TaskAssignment => {
9534 if task_assignment__.is_some() {
9535 return Err(serde::de::Error::duplicate_field("taskAssignment"));
9536 }
9537 task_assignment__ = Some(map_.next_value()?);
9538 }
9539 }
9540 }
9541 Ok(ListCompactTaskAssignmentResponse {
9542 task_assignment: task_assignment__.unwrap_or_default(),
9543 })
9544 }
9545 }
9546 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
9547 }
9548}
9549impl serde::Serialize for ListCompactTaskProgressRequest {
9550 #[allow(deprecated)]
9551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9552 where
9553 S: serde::Serializer,
9554 {
9555 use serde::ser::SerializeStruct;
9556 let len = 0;
9557 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
9558 struct_ser.end()
9559 }
9560}
9561impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
9562 #[allow(deprecated)]
9563 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9564 where
9565 D: serde::Deserializer<'de>,
9566 {
9567 const FIELDS: &[&str] = &[
9568 ];
9569
9570 #[allow(clippy::enum_variant_names)]
9571 enum GeneratedField {
9572 }
9573 impl<'de> serde::Deserialize<'de> for GeneratedField {
9574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9575 where
9576 D: serde::Deserializer<'de>,
9577 {
9578 struct GeneratedVisitor;
9579
9580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9581 type Value = GeneratedField;
9582
9583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9584 write!(formatter, "expected one of: {:?}", &FIELDS)
9585 }
9586
9587 #[allow(unused_variables)]
9588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9589 where
9590 E: serde::de::Error,
9591 {
9592 Err(serde::de::Error::unknown_field(value, FIELDS))
9593 }
9594 }
9595 deserializer.deserialize_identifier(GeneratedVisitor)
9596 }
9597 }
9598 struct GeneratedVisitor;
9599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9600 type Value = ListCompactTaskProgressRequest;
9601
9602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9603 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
9604 }
9605
9606 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
9607 where
9608 V: serde::de::MapAccess<'de>,
9609 {
9610 while map_.next_key::<GeneratedField>()?.is_some() {
9611 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9612 }
9613 Ok(ListCompactTaskProgressRequest {
9614 })
9615 }
9616 }
9617 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
9618 }
9619}
9620impl serde::Serialize for ListCompactTaskProgressResponse {
9621 #[allow(deprecated)]
9622 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9623 where
9624 S: serde::Serializer,
9625 {
9626 use serde::ser::SerializeStruct;
9627 let mut len = 0;
9628 if !self.task_progress.is_empty() {
9629 len += 1;
9630 }
9631 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
9632 if !self.task_progress.is_empty() {
9633 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
9634 }
9635 struct_ser.end()
9636 }
9637}
9638impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
9639 #[allow(deprecated)]
9640 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9641 where
9642 D: serde::Deserializer<'de>,
9643 {
9644 const FIELDS: &[&str] = &[
9645 "task_progress",
9646 "taskProgress",
9647 ];
9648
9649 #[allow(clippy::enum_variant_names)]
9650 enum GeneratedField {
9651 TaskProgress,
9652 }
9653 impl<'de> serde::Deserialize<'de> for GeneratedField {
9654 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9655 where
9656 D: serde::Deserializer<'de>,
9657 {
9658 struct GeneratedVisitor;
9659
9660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9661 type Value = GeneratedField;
9662
9663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9664 write!(formatter, "expected one of: {:?}", &FIELDS)
9665 }
9666
9667 #[allow(unused_variables)]
9668 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9669 where
9670 E: serde::de::Error,
9671 {
9672 match value {
9673 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
9674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9675 }
9676 }
9677 }
9678 deserializer.deserialize_identifier(GeneratedVisitor)
9679 }
9680 }
9681 struct GeneratedVisitor;
9682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9683 type Value = ListCompactTaskProgressResponse;
9684
9685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9686 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
9687 }
9688
9689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
9690 where
9691 V: serde::de::MapAccess<'de>,
9692 {
9693 let mut task_progress__ = None;
9694 while let Some(k) = map_.next_key()? {
9695 match k {
9696 GeneratedField::TaskProgress => {
9697 if task_progress__.is_some() {
9698 return Err(serde::de::Error::duplicate_field("taskProgress"));
9699 }
9700 task_progress__ = Some(map_.next_value()?);
9701 }
9702 }
9703 }
9704 Ok(ListCompactTaskProgressResponse {
9705 task_progress: task_progress__.unwrap_or_default(),
9706 })
9707 }
9708 }
9709 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
9710 }
9711}
9712impl serde::Serialize for ListHummockMetaConfigRequest {
9713 #[allow(deprecated)]
9714 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9715 where
9716 S: serde::Serializer,
9717 {
9718 use serde::ser::SerializeStruct;
9719 let len = 0;
9720 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
9721 struct_ser.end()
9722 }
9723}
9724impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
9725 #[allow(deprecated)]
9726 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9727 where
9728 D: serde::Deserializer<'de>,
9729 {
9730 const FIELDS: &[&str] = &[
9731 ];
9732
9733 #[allow(clippy::enum_variant_names)]
9734 enum GeneratedField {
9735 }
9736 impl<'de> serde::Deserialize<'de> for GeneratedField {
9737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9738 where
9739 D: serde::Deserializer<'de>,
9740 {
9741 struct GeneratedVisitor;
9742
9743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9744 type Value = GeneratedField;
9745
9746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9747 write!(formatter, "expected one of: {:?}", &FIELDS)
9748 }
9749
9750 #[allow(unused_variables)]
9751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9752 where
9753 E: serde::de::Error,
9754 {
9755 Err(serde::de::Error::unknown_field(value, FIELDS))
9756 }
9757 }
9758 deserializer.deserialize_identifier(GeneratedVisitor)
9759 }
9760 }
9761 struct GeneratedVisitor;
9762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9763 type Value = ListHummockMetaConfigRequest;
9764
9765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9766 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
9767 }
9768
9769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
9770 where
9771 V: serde::de::MapAccess<'de>,
9772 {
9773 while map_.next_key::<GeneratedField>()?.is_some() {
9774 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9775 }
9776 Ok(ListHummockMetaConfigRequest {
9777 })
9778 }
9779 }
9780 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
9781 }
9782}
9783impl serde::Serialize for ListHummockMetaConfigResponse {
9784 #[allow(deprecated)]
9785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9786 where
9787 S: serde::Serializer,
9788 {
9789 use serde::ser::SerializeStruct;
9790 let mut len = 0;
9791 if !self.configs.is_empty() {
9792 len += 1;
9793 }
9794 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
9795 if !self.configs.is_empty() {
9796 struct_ser.serialize_field("configs", &self.configs)?;
9797 }
9798 struct_ser.end()
9799 }
9800}
9801impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
9802 #[allow(deprecated)]
9803 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9804 where
9805 D: serde::Deserializer<'de>,
9806 {
9807 const FIELDS: &[&str] = &[
9808 "configs",
9809 ];
9810
9811 #[allow(clippy::enum_variant_names)]
9812 enum GeneratedField {
9813 Configs,
9814 }
9815 impl<'de> serde::Deserialize<'de> for GeneratedField {
9816 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9817 where
9818 D: serde::Deserializer<'de>,
9819 {
9820 struct GeneratedVisitor;
9821
9822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9823 type Value = GeneratedField;
9824
9825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9826 write!(formatter, "expected one of: {:?}", &FIELDS)
9827 }
9828
9829 #[allow(unused_variables)]
9830 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9831 where
9832 E: serde::de::Error,
9833 {
9834 match value {
9835 "configs" => Ok(GeneratedField::Configs),
9836 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9837 }
9838 }
9839 }
9840 deserializer.deserialize_identifier(GeneratedVisitor)
9841 }
9842 }
9843 struct GeneratedVisitor;
9844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9845 type Value = ListHummockMetaConfigResponse;
9846
9847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9848 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
9849 }
9850
9851 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
9852 where
9853 V: serde::de::MapAccess<'de>,
9854 {
9855 let mut configs__ = None;
9856 while let Some(k) = map_.next_key()? {
9857 match k {
9858 GeneratedField::Configs => {
9859 if configs__.is_some() {
9860 return Err(serde::de::Error::duplicate_field("configs"));
9861 }
9862 configs__ = Some(
9863 map_.next_value::<std::collections::HashMap<_, _>>()?
9864 );
9865 }
9866 }
9867 }
9868 Ok(ListHummockMetaConfigResponse {
9869 configs: configs__.unwrap_or_default(),
9870 })
9871 }
9872 }
9873 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
9874 }
9875}
9876impl serde::Serialize for ListVersionDeltasRequest {
9877 #[allow(deprecated)]
9878 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9879 where
9880 S: serde::Serializer,
9881 {
9882 use serde::ser::SerializeStruct;
9883 let mut len = 0;
9884 if self.start_id != 0 {
9885 len += 1;
9886 }
9887 if self.num_limit != 0 {
9888 len += 1;
9889 }
9890 if self.committed_epoch_limit != 0 {
9891 len += 1;
9892 }
9893 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
9894 if self.start_id != 0 {
9895 #[allow(clippy::needless_borrow)]
9896 #[allow(clippy::needless_borrows_for_generic_args)]
9897 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
9898 }
9899 if self.num_limit != 0 {
9900 struct_ser.serialize_field("numLimit", &self.num_limit)?;
9901 }
9902 if self.committed_epoch_limit != 0 {
9903 #[allow(clippy::needless_borrow)]
9904 #[allow(clippy::needless_borrows_for_generic_args)]
9905 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
9906 }
9907 struct_ser.end()
9908 }
9909}
9910impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
9911 #[allow(deprecated)]
9912 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9913 where
9914 D: serde::Deserializer<'de>,
9915 {
9916 const FIELDS: &[&str] = &[
9917 "start_id",
9918 "startId",
9919 "num_limit",
9920 "numLimit",
9921 "committed_epoch_limit",
9922 "committedEpochLimit",
9923 ];
9924
9925 #[allow(clippy::enum_variant_names)]
9926 enum GeneratedField {
9927 StartId,
9928 NumLimit,
9929 CommittedEpochLimit,
9930 }
9931 impl<'de> serde::Deserialize<'de> for GeneratedField {
9932 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9933 where
9934 D: serde::Deserializer<'de>,
9935 {
9936 struct GeneratedVisitor;
9937
9938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9939 type Value = GeneratedField;
9940
9941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9942 write!(formatter, "expected one of: {:?}", &FIELDS)
9943 }
9944
9945 #[allow(unused_variables)]
9946 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9947 where
9948 E: serde::de::Error,
9949 {
9950 match value {
9951 "startId" | "start_id" => Ok(GeneratedField::StartId),
9952 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
9953 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
9954 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9955 }
9956 }
9957 }
9958 deserializer.deserialize_identifier(GeneratedVisitor)
9959 }
9960 }
9961 struct GeneratedVisitor;
9962 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9963 type Value = ListVersionDeltasRequest;
9964
9965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9966 formatter.write_str("struct hummock.ListVersionDeltasRequest")
9967 }
9968
9969 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
9970 where
9971 V: serde::de::MapAccess<'de>,
9972 {
9973 let mut start_id__ = None;
9974 let mut num_limit__ = None;
9975 let mut committed_epoch_limit__ = None;
9976 while let Some(k) = map_.next_key()? {
9977 match k {
9978 GeneratedField::StartId => {
9979 if start_id__.is_some() {
9980 return Err(serde::de::Error::duplicate_field("startId"));
9981 }
9982 start_id__ =
9983 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9984 ;
9985 }
9986 GeneratedField::NumLimit => {
9987 if num_limit__.is_some() {
9988 return Err(serde::de::Error::duplicate_field("numLimit"));
9989 }
9990 num_limit__ =
9991 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9992 ;
9993 }
9994 GeneratedField::CommittedEpochLimit => {
9995 if committed_epoch_limit__.is_some() {
9996 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
9997 }
9998 committed_epoch_limit__ =
9999 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10000 ;
10001 }
10002 }
10003 }
10004 Ok(ListVersionDeltasRequest {
10005 start_id: start_id__.unwrap_or_default(),
10006 num_limit: num_limit__.unwrap_or_default(),
10007 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
10008 })
10009 }
10010 }
10011 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
10012 }
10013}
10014impl serde::Serialize for ListVersionDeltasResponse {
10015 #[allow(deprecated)]
10016 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10017 where
10018 S: serde::Serializer,
10019 {
10020 use serde::ser::SerializeStruct;
10021 let mut len = 0;
10022 if self.version_deltas.is_some() {
10023 len += 1;
10024 }
10025 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
10026 if let Some(v) = self.version_deltas.as_ref() {
10027 struct_ser.serialize_field("versionDeltas", v)?;
10028 }
10029 struct_ser.end()
10030 }
10031}
10032impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
10033 #[allow(deprecated)]
10034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10035 where
10036 D: serde::Deserializer<'de>,
10037 {
10038 const FIELDS: &[&str] = &[
10039 "version_deltas",
10040 "versionDeltas",
10041 ];
10042
10043 #[allow(clippy::enum_variant_names)]
10044 enum GeneratedField {
10045 VersionDeltas,
10046 }
10047 impl<'de> serde::Deserialize<'de> for GeneratedField {
10048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10049 where
10050 D: serde::Deserializer<'de>,
10051 {
10052 struct GeneratedVisitor;
10053
10054 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10055 type Value = GeneratedField;
10056
10057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10058 write!(formatter, "expected one of: {:?}", &FIELDS)
10059 }
10060
10061 #[allow(unused_variables)]
10062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10063 where
10064 E: serde::de::Error,
10065 {
10066 match value {
10067 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
10068 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10069 }
10070 }
10071 }
10072 deserializer.deserialize_identifier(GeneratedVisitor)
10073 }
10074 }
10075 struct GeneratedVisitor;
10076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10077 type Value = ListVersionDeltasResponse;
10078
10079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10080 formatter.write_str("struct hummock.ListVersionDeltasResponse")
10081 }
10082
10083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
10084 where
10085 V: serde::de::MapAccess<'de>,
10086 {
10087 let mut version_deltas__ = None;
10088 while let Some(k) = map_.next_key()? {
10089 match k {
10090 GeneratedField::VersionDeltas => {
10091 if version_deltas__.is_some() {
10092 return Err(serde::de::Error::duplicate_field("versionDeltas"));
10093 }
10094 version_deltas__ = map_.next_value()?;
10095 }
10096 }
10097 }
10098 Ok(ListVersionDeltasResponse {
10099 version_deltas: version_deltas__,
10100 })
10101 }
10102 }
10103 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
10104 }
10105}
10106impl serde::Serialize for MergeCompactionGroupRequest {
10107 #[allow(deprecated)]
10108 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10109 where
10110 S: serde::Serializer,
10111 {
10112 use serde::ser::SerializeStruct;
10113 let mut len = 0;
10114 if self.left_group_id != 0 {
10115 len += 1;
10116 }
10117 if self.right_group_id != 0 {
10118 len += 1;
10119 }
10120 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
10121 if self.left_group_id != 0 {
10122 #[allow(clippy::needless_borrow)]
10123 #[allow(clippy::needless_borrows_for_generic_args)]
10124 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
10125 }
10126 if self.right_group_id != 0 {
10127 #[allow(clippy::needless_borrow)]
10128 #[allow(clippy::needless_borrows_for_generic_args)]
10129 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
10130 }
10131 struct_ser.end()
10132 }
10133}
10134impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
10135 #[allow(deprecated)]
10136 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10137 where
10138 D: serde::Deserializer<'de>,
10139 {
10140 const FIELDS: &[&str] = &[
10141 "left_group_id",
10142 "leftGroupId",
10143 "right_group_id",
10144 "rightGroupId",
10145 ];
10146
10147 #[allow(clippy::enum_variant_names)]
10148 enum GeneratedField {
10149 LeftGroupId,
10150 RightGroupId,
10151 }
10152 impl<'de> serde::Deserialize<'de> for GeneratedField {
10153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10154 where
10155 D: serde::Deserializer<'de>,
10156 {
10157 struct GeneratedVisitor;
10158
10159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10160 type Value = GeneratedField;
10161
10162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10163 write!(formatter, "expected one of: {:?}", &FIELDS)
10164 }
10165
10166 #[allow(unused_variables)]
10167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10168 where
10169 E: serde::de::Error,
10170 {
10171 match value {
10172 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
10173 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
10174 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10175 }
10176 }
10177 }
10178 deserializer.deserialize_identifier(GeneratedVisitor)
10179 }
10180 }
10181 struct GeneratedVisitor;
10182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10183 type Value = MergeCompactionGroupRequest;
10184
10185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10186 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
10187 }
10188
10189 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
10190 where
10191 V: serde::de::MapAccess<'de>,
10192 {
10193 let mut left_group_id__ = None;
10194 let mut right_group_id__ = None;
10195 while let Some(k) = map_.next_key()? {
10196 match k {
10197 GeneratedField::LeftGroupId => {
10198 if left_group_id__.is_some() {
10199 return Err(serde::de::Error::duplicate_field("leftGroupId"));
10200 }
10201 left_group_id__ =
10202 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10203 ;
10204 }
10205 GeneratedField::RightGroupId => {
10206 if right_group_id__.is_some() {
10207 return Err(serde::de::Error::duplicate_field("rightGroupId"));
10208 }
10209 right_group_id__ =
10210 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10211 ;
10212 }
10213 }
10214 }
10215 Ok(MergeCompactionGroupRequest {
10216 left_group_id: left_group_id__.unwrap_or_default(),
10217 right_group_id: right_group_id__.unwrap_or_default(),
10218 })
10219 }
10220 }
10221 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
10222 }
10223}
10224impl serde::Serialize for MergeCompactionGroupResponse {
10225 #[allow(deprecated)]
10226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10227 where
10228 S: serde::Serializer,
10229 {
10230 use serde::ser::SerializeStruct;
10231 let len = 0;
10232 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
10233 struct_ser.end()
10234 }
10235}
10236impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
10237 #[allow(deprecated)]
10238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10239 where
10240 D: serde::Deserializer<'de>,
10241 {
10242 const FIELDS: &[&str] = &[
10243 ];
10244
10245 #[allow(clippy::enum_variant_names)]
10246 enum GeneratedField {
10247 }
10248 impl<'de> serde::Deserialize<'de> for GeneratedField {
10249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10250 where
10251 D: serde::Deserializer<'de>,
10252 {
10253 struct GeneratedVisitor;
10254
10255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10256 type Value = GeneratedField;
10257
10258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10259 write!(formatter, "expected one of: {:?}", &FIELDS)
10260 }
10261
10262 #[allow(unused_variables)]
10263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10264 where
10265 E: serde::de::Error,
10266 {
10267 Err(serde::de::Error::unknown_field(value, FIELDS))
10268 }
10269 }
10270 deserializer.deserialize_identifier(GeneratedVisitor)
10271 }
10272 }
10273 struct GeneratedVisitor;
10274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10275 type Value = MergeCompactionGroupResponse;
10276
10277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10278 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
10279 }
10280
10281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
10282 where
10283 V: serde::de::MapAccess<'de>,
10284 {
10285 while map_.next_key::<GeneratedField>()?.is_some() {
10286 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10287 }
10288 Ok(MergeCompactionGroupResponse {
10289 })
10290 }
10291 }
10292 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
10293 }
10294}
10295impl serde::Serialize for NewL0SubLevel {
10296 #[allow(deprecated)]
10297 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10298 where
10299 S: serde::Serializer,
10300 {
10301 use serde::ser::SerializeStruct;
10302 let mut len = 0;
10303 if !self.inserted_table_infos.is_empty() {
10304 len += 1;
10305 }
10306 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
10307 if !self.inserted_table_infos.is_empty() {
10308 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
10309 }
10310 struct_ser.end()
10311 }
10312}
10313impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
10314 #[allow(deprecated)]
10315 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10316 where
10317 D: serde::Deserializer<'de>,
10318 {
10319 const FIELDS: &[&str] = &[
10320 "inserted_table_infos",
10321 "insertedTableInfos",
10322 ];
10323
10324 #[allow(clippy::enum_variant_names)]
10325 enum GeneratedField {
10326 InsertedTableInfos,
10327 }
10328 impl<'de> serde::Deserialize<'de> for GeneratedField {
10329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10330 where
10331 D: serde::Deserializer<'de>,
10332 {
10333 struct GeneratedVisitor;
10334
10335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10336 type Value = GeneratedField;
10337
10338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10339 write!(formatter, "expected one of: {:?}", &FIELDS)
10340 }
10341
10342 #[allow(unused_variables)]
10343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10344 where
10345 E: serde::de::Error,
10346 {
10347 match value {
10348 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
10349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10350 }
10351 }
10352 }
10353 deserializer.deserialize_identifier(GeneratedVisitor)
10354 }
10355 }
10356 struct GeneratedVisitor;
10357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10358 type Value = NewL0SubLevel;
10359
10360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10361 formatter.write_str("struct hummock.NewL0SubLevel")
10362 }
10363
10364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
10365 where
10366 V: serde::de::MapAccess<'de>,
10367 {
10368 let mut inserted_table_infos__ = None;
10369 while let Some(k) = map_.next_key()? {
10370 match k {
10371 GeneratedField::InsertedTableInfos => {
10372 if inserted_table_infos__.is_some() {
10373 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
10374 }
10375 inserted_table_infos__ = Some(map_.next_value()?);
10376 }
10377 }
10378 }
10379 Ok(NewL0SubLevel {
10380 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
10381 })
10382 }
10383 }
10384 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
10385 }
10386}
10387impl serde::Serialize for OverlappingLevel {
10388 #[allow(deprecated)]
10389 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10390 where
10391 S: serde::Serializer,
10392 {
10393 use serde::ser::SerializeStruct;
10394 let mut len = 0;
10395 if !self.sub_levels.is_empty() {
10396 len += 1;
10397 }
10398 if self.total_file_size != 0 {
10399 len += 1;
10400 }
10401 if self.uncompressed_file_size != 0 {
10402 len += 1;
10403 }
10404 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
10405 if !self.sub_levels.is_empty() {
10406 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
10407 }
10408 if self.total_file_size != 0 {
10409 #[allow(clippy::needless_borrow)]
10410 #[allow(clippy::needless_borrows_for_generic_args)]
10411 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
10412 }
10413 if self.uncompressed_file_size != 0 {
10414 #[allow(clippy::needless_borrow)]
10415 #[allow(clippy::needless_borrows_for_generic_args)]
10416 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
10417 }
10418 struct_ser.end()
10419 }
10420}
10421impl<'de> serde::Deserialize<'de> for OverlappingLevel {
10422 #[allow(deprecated)]
10423 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10424 where
10425 D: serde::Deserializer<'de>,
10426 {
10427 const FIELDS: &[&str] = &[
10428 "sub_levels",
10429 "subLevels",
10430 "total_file_size",
10431 "totalFileSize",
10432 "uncompressed_file_size",
10433 "uncompressedFileSize",
10434 ];
10435
10436 #[allow(clippy::enum_variant_names)]
10437 enum GeneratedField {
10438 SubLevels,
10439 TotalFileSize,
10440 UncompressedFileSize,
10441 }
10442 impl<'de> serde::Deserialize<'de> for GeneratedField {
10443 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10444 where
10445 D: serde::Deserializer<'de>,
10446 {
10447 struct GeneratedVisitor;
10448
10449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10450 type Value = GeneratedField;
10451
10452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10453 write!(formatter, "expected one of: {:?}", &FIELDS)
10454 }
10455
10456 #[allow(unused_variables)]
10457 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10458 where
10459 E: serde::de::Error,
10460 {
10461 match value {
10462 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
10463 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
10464 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
10465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10466 }
10467 }
10468 }
10469 deserializer.deserialize_identifier(GeneratedVisitor)
10470 }
10471 }
10472 struct GeneratedVisitor;
10473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10474 type Value = OverlappingLevel;
10475
10476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10477 formatter.write_str("struct hummock.OverlappingLevel")
10478 }
10479
10480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
10481 where
10482 V: serde::de::MapAccess<'de>,
10483 {
10484 let mut sub_levels__ = None;
10485 let mut total_file_size__ = None;
10486 let mut uncompressed_file_size__ = None;
10487 while let Some(k) = map_.next_key()? {
10488 match k {
10489 GeneratedField::SubLevels => {
10490 if sub_levels__.is_some() {
10491 return Err(serde::de::Error::duplicate_field("subLevels"));
10492 }
10493 sub_levels__ = Some(map_.next_value()?);
10494 }
10495 GeneratedField::TotalFileSize => {
10496 if total_file_size__.is_some() {
10497 return Err(serde::de::Error::duplicate_field("totalFileSize"));
10498 }
10499 total_file_size__ =
10500 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10501 ;
10502 }
10503 GeneratedField::UncompressedFileSize => {
10504 if uncompressed_file_size__.is_some() {
10505 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
10506 }
10507 uncompressed_file_size__ =
10508 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10509 ;
10510 }
10511 }
10512 }
10513 Ok(OverlappingLevel {
10514 sub_levels: sub_levels__.unwrap_or_default(),
10515 total_file_size: total_file_size__.unwrap_or_default(),
10516 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
10517 })
10518 }
10519 }
10520 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
10521 }
10522}
10523impl serde::Serialize for PinVersionRequest {
10524 #[allow(deprecated)]
10525 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10526 where
10527 S: serde::Serializer,
10528 {
10529 use serde::ser::SerializeStruct;
10530 let mut len = 0;
10531 if self.context_id != 0 {
10532 len += 1;
10533 }
10534 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
10535 if self.context_id != 0 {
10536 struct_ser.serialize_field("contextId", &self.context_id)?;
10537 }
10538 struct_ser.end()
10539 }
10540}
10541impl<'de> serde::Deserialize<'de> for PinVersionRequest {
10542 #[allow(deprecated)]
10543 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10544 where
10545 D: serde::Deserializer<'de>,
10546 {
10547 const FIELDS: &[&str] = &[
10548 "context_id",
10549 "contextId",
10550 ];
10551
10552 #[allow(clippy::enum_variant_names)]
10553 enum GeneratedField {
10554 ContextId,
10555 }
10556 impl<'de> serde::Deserialize<'de> for GeneratedField {
10557 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10558 where
10559 D: serde::Deserializer<'de>,
10560 {
10561 struct GeneratedVisitor;
10562
10563 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10564 type Value = GeneratedField;
10565
10566 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10567 write!(formatter, "expected one of: {:?}", &FIELDS)
10568 }
10569
10570 #[allow(unused_variables)]
10571 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10572 where
10573 E: serde::de::Error,
10574 {
10575 match value {
10576 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
10577 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10578 }
10579 }
10580 }
10581 deserializer.deserialize_identifier(GeneratedVisitor)
10582 }
10583 }
10584 struct GeneratedVisitor;
10585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10586 type Value = PinVersionRequest;
10587
10588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10589 formatter.write_str("struct hummock.PinVersionRequest")
10590 }
10591
10592 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
10593 where
10594 V: serde::de::MapAccess<'de>,
10595 {
10596 let mut context_id__ = None;
10597 while let Some(k) = map_.next_key()? {
10598 match k {
10599 GeneratedField::ContextId => {
10600 if context_id__.is_some() {
10601 return Err(serde::de::Error::duplicate_field("contextId"));
10602 }
10603 context_id__ =
10604 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10605 ;
10606 }
10607 }
10608 }
10609 Ok(PinVersionRequest {
10610 context_id: context_id__.unwrap_or_default(),
10611 })
10612 }
10613 }
10614 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
10615 }
10616}
10617impl serde::Serialize for PinVersionResponse {
10618 #[allow(deprecated)]
10619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10620 where
10621 S: serde::Serializer,
10622 {
10623 use serde::ser::SerializeStruct;
10624 let mut len = 0;
10625 if self.pinned_version.is_some() {
10626 len += 1;
10627 }
10628 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
10629 if let Some(v) = self.pinned_version.as_ref() {
10630 struct_ser.serialize_field("pinnedVersion", v)?;
10631 }
10632 struct_ser.end()
10633 }
10634}
10635impl<'de> serde::Deserialize<'de> for PinVersionResponse {
10636 #[allow(deprecated)]
10637 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10638 where
10639 D: serde::Deserializer<'de>,
10640 {
10641 const FIELDS: &[&str] = &[
10642 "pinned_version",
10643 "pinnedVersion",
10644 ];
10645
10646 #[allow(clippy::enum_variant_names)]
10647 enum GeneratedField {
10648 PinnedVersion,
10649 }
10650 impl<'de> serde::Deserialize<'de> for GeneratedField {
10651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10652 where
10653 D: serde::Deserializer<'de>,
10654 {
10655 struct GeneratedVisitor;
10656
10657 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10658 type Value = GeneratedField;
10659
10660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10661 write!(formatter, "expected one of: {:?}", &FIELDS)
10662 }
10663
10664 #[allow(unused_variables)]
10665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10666 where
10667 E: serde::de::Error,
10668 {
10669 match value {
10670 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
10671 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10672 }
10673 }
10674 }
10675 deserializer.deserialize_identifier(GeneratedVisitor)
10676 }
10677 }
10678 struct GeneratedVisitor;
10679 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10680 type Value = PinVersionResponse;
10681
10682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10683 formatter.write_str("struct hummock.PinVersionResponse")
10684 }
10685
10686 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
10687 where
10688 V: serde::de::MapAccess<'de>,
10689 {
10690 let mut pinned_version__ = None;
10691 while let Some(k) = map_.next_key()? {
10692 match k {
10693 GeneratedField::PinnedVersion => {
10694 if pinned_version__.is_some() {
10695 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
10696 }
10697 pinned_version__ = map_.next_value()?;
10698 }
10699 }
10700 }
10701 Ok(PinVersionResponse {
10702 pinned_version: pinned_version__,
10703 })
10704 }
10705 }
10706 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
10707 }
10708}
10709impl serde::Serialize for PinnedVersionsSummary {
10710 #[allow(deprecated)]
10711 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10712 where
10713 S: serde::Serializer,
10714 {
10715 use serde::ser::SerializeStruct;
10716 let mut len = 0;
10717 if !self.pinned_versions.is_empty() {
10718 len += 1;
10719 }
10720 if !self.workers.is_empty() {
10721 len += 1;
10722 }
10723 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
10724 if !self.pinned_versions.is_empty() {
10725 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
10726 }
10727 if !self.workers.is_empty() {
10728 struct_ser.serialize_field("workers", &self.workers)?;
10729 }
10730 struct_ser.end()
10731 }
10732}
10733impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
10734 #[allow(deprecated)]
10735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10736 where
10737 D: serde::Deserializer<'de>,
10738 {
10739 const FIELDS: &[&str] = &[
10740 "pinned_versions",
10741 "pinnedVersions",
10742 "workers",
10743 ];
10744
10745 #[allow(clippy::enum_variant_names)]
10746 enum GeneratedField {
10747 PinnedVersions,
10748 Workers,
10749 }
10750 impl<'de> serde::Deserialize<'de> for GeneratedField {
10751 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10752 where
10753 D: serde::Deserializer<'de>,
10754 {
10755 struct GeneratedVisitor;
10756
10757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10758 type Value = GeneratedField;
10759
10760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10761 write!(formatter, "expected one of: {:?}", &FIELDS)
10762 }
10763
10764 #[allow(unused_variables)]
10765 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10766 where
10767 E: serde::de::Error,
10768 {
10769 match value {
10770 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
10771 "workers" => Ok(GeneratedField::Workers),
10772 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10773 }
10774 }
10775 }
10776 deserializer.deserialize_identifier(GeneratedVisitor)
10777 }
10778 }
10779 struct GeneratedVisitor;
10780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10781 type Value = PinnedVersionsSummary;
10782
10783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10784 formatter.write_str("struct hummock.PinnedVersionsSummary")
10785 }
10786
10787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
10788 where
10789 V: serde::de::MapAccess<'de>,
10790 {
10791 let mut pinned_versions__ = None;
10792 let mut workers__ = None;
10793 while let Some(k) = map_.next_key()? {
10794 match k {
10795 GeneratedField::PinnedVersions => {
10796 if pinned_versions__.is_some() {
10797 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
10798 }
10799 pinned_versions__ = Some(map_.next_value()?);
10800 }
10801 GeneratedField::Workers => {
10802 if workers__.is_some() {
10803 return Err(serde::de::Error::duplicate_field("workers"));
10804 }
10805 workers__ = Some(
10806 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10807 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10808 );
10809 }
10810 }
10811 }
10812 Ok(PinnedVersionsSummary {
10813 pinned_versions: pinned_versions__.unwrap_or_default(),
10814 workers: workers__.unwrap_or_default(),
10815 })
10816 }
10817 }
10818 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
10819 }
10820}
10821impl serde::Serialize for ReplayVersionDeltaRequest {
10822 #[allow(deprecated)]
10823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10824 where
10825 S: serde::Serializer,
10826 {
10827 use serde::ser::SerializeStruct;
10828 let mut len = 0;
10829 if self.version_delta.is_some() {
10830 len += 1;
10831 }
10832 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
10833 if let Some(v) = self.version_delta.as_ref() {
10834 struct_ser.serialize_field("versionDelta", v)?;
10835 }
10836 struct_ser.end()
10837 }
10838}
10839impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
10840 #[allow(deprecated)]
10841 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10842 where
10843 D: serde::Deserializer<'de>,
10844 {
10845 const FIELDS: &[&str] = &[
10846 "version_delta",
10847 "versionDelta",
10848 ];
10849
10850 #[allow(clippy::enum_variant_names)]
10851 enum GeneratedField {
10852 VersionDelta,
10853 }
10854 impl<'de> serde::Deserialize<'de> for GeneratedField {
10855 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10856 where
10857 D: serde::Deserializer<'de>,
10858 {
10859 struct GeneratedVisitor;
10860
10861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10862 type Value = GeneratedField;
10863
10864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10865 write!(formatter, "expected one of: {:?}", &FIELDS)
10866 }
10867
10868 #[allow(unused_variables)]
10869 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10870 where
10871 E: serde::de::Error,
10872 {
10873 match value {
10874 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
10875 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10876 }
10877 }
10878 }
10879 deserializer.deserialize_identifier(GeneratedVisitor)
10880 }
10881 }
10882 struct GeneratedVisitor;
10883 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10884 type Value = ReplayVersionDeltaRequest;
10885
10886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10887 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
10888 }
10889
10890 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
10891 where
10892 V: serde::de::MapAccess<'de>,
10893 {
10894 let mut version_delta__ = None;
10895 while let Some(k) = map_.next_key()? {
10896 match k {
10897 GeneratedField::VersionDelta => {
10898 if version_delta__.is_some() {
10899 return Err(serde::de::Error::duplicate_field("versionDelta"));
10900 }
10901 version_delta__ = map_.next_value()?;
10902 }
10903 }
10904 }
10905 Ok(ReplayVersionDeltaRequest {
10906 version_delta: version_delta__,
10907 })
10908 }
10909 }
10910 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
10911 }
10912}
10913impl serde::Serialize for ReplayVersionDeltaResponse {
10914 #[allow(deprecated)]
10915 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10916 where
10917 S: serde::Serializer,
10918 {
10919 use serde::ser::SerializeStruct;
10920 let mut len = 0;
10921 if self.version.is_some() {
10922 len += 1;
10923 }
10924 if !self.modified_compaction_groups.is_empty() {
10925 len += 1;
10926 }
10927 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
10928 if let Some(v) = self.version.as_ref() {
10929 struct_ser.serialize_field("version", v)?;
10930 }
10931 if !self.modified_compaction_groups.is_empty() {
10932 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
10933 }
10934 struct_ser.end()
10935 }
10936}
10937impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
10938 #[allow(deprecated)]
10939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10940 where
10941 D: serde::Deserializer<'de>,
10942 {
10943 const FIELDS: &[&str] = &[
10944 "version",
10945 "modified_compaction_groups",
10946 "modifiedCompactionGroups",
10947 ];
10948
10949 #[allow(clippy::enum_variant_names)]
10950 enum GeneratedField {
10951 Version,
10952 ModifiedCompactionGroups,
10953 }
10954 impl<'de> serde::Deserialize<'de> for GeneratedField {
10955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10956 where
10957 D: serde::Deserializer<'de>,
10958 {
10959 struct GeneratedVisitor;
10960
10961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10962 type Value = GeneratedField;
10963
10964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10965 write!(formatter, "expected one of: {:?}", &FIELDS)
10966 }
10967
10968 #[allow(unused_variables)]
10969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10970 where
10971 E: serde::de::Error,
10972 {
10973 match value {
10974 "version" => Ok(GeneratedField::Version),
10975 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
10976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10977 }
10978 }
10979 }
10980 deserializer.deserialize_identifier(GeneratedVisitor)
10981 }
10982 }
10983 struct GeneratedVisitor;
10984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10985 type Value = ReplayVersionDeltaResponse;
10986
10987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10988 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
10989 }
10990
10991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
10992 where
10993 V: serde::de::MapAccess<'de>,
10994 {
10995 let mut version__ = None;
10996 let mut modified_compaction_groups__ = None;
10997 while let Some(k) = map_.next_key()? {
10998 match k {
10999 GeneratedField::Version => {
11000 if version__.is_some() {
11001 return Err(serde::de::Error::duplicate_field("version"));
11002 }
11003 version__ = map_.next_value()?;
11004 }
11005 GeneratedField::ModifiedCompactionGroups => {
11006 if modified_compaction_groups__.is_some() {
11007 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
11008 }
11009 modified_compaction_groups__ =
11010 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11011 .into_iter().map(|x| x.0).collect())
11012 ;
11013 }
11014 }
11015 }
11016 Ok(ReplayVersionDeltaResponse {
11017 version: version__,
11018 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
11019 })
11020 }
11021 }
11022 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
11023 }
11024}
11025impl serde::Serialize for ReportCompactionTaskRequest {
11026 #[allow(deprecated)]
11027 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11028 where
11029 S: serde::Serializer,
11030 {
11031 use serde::ser::SerializeStruct;
11032 let mut len = 0;
11033 if self.event.is_some() {
11034 len += 1;
11035 }
11036 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
11037 if let Some(v) = self.event.as_ref() {
11038 match v {
11039 report_compaction_task_request::Event::ReportTask(v) => {
11040 struct_ser.serialize_field("reportTask", v)?;
11041 }
11042 report_compaction_task_request::Event::HeartBeat(v) => {
11043 struct_ser.serialize_field("heartBeat", v)?;
11044 }
11045 }
11046 }
11047 struct_ser.end()
11048 }
11049}
11050impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
11051 #[allow(deprecated)]
11052 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11053 where
11054 D: serde::Deserializer<'de>,
11055 {
11056 const FIELDS: &[&str] = &[
11057 "report_task",
11058 "reportTask",
11059 "heart_beat",
11060 "heartBeat",
11061 ];
11062
11063 #[allow(clippy::enum_variant_names)]
11064 enum GeneratedField {
11065 ReportTask,
11066 HeartBeat,
11067 }
11068 impl<'de> serde::Deserialize<'de> for GeneratedField {
11069 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11070 where
11071 D: serde::Deserializer<'de>,
11072 {
11073 struct GeneratedVisitor;
11074
11075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11076 type Value = GeneratedField;
11077
11078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11079 write!(formatter, "expected one of: {:?}", &FIELDS)
11080 }
11081
11082 #[allow(unused_variables)]
11083 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11084 where
11085 E: serde::de::Error,
11086 {
11087 match value {
11088 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
11089 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
11090 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11091 }
11092 }
11093 }
11094 deserializer.deserialize_identifier(GeneratedVisitor)
11095 }
11096 }
11097 struct GeneratedVisitor;
11098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11099 type Value = ReportCompactionTaskRequest;
11100
11101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11102 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
11103 }
11104
11105 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
11106 where
11107 V: serde::de::MapAccess<'de>,
11108 {
11109 let mut event__ = None;
11110 while let Some(k) = map_.next_key()? {
11111 match k {
11112 GeneratedField::ReportTask => {
11113 if event__.is_some() {
11114 return Err(serde::de::Error::duplicate_field("reportTask"));
11115 }
11116 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
11117;
11118 }
11119 GeneratedField::HeartBeat => {
11120 if event__.is_some() {
11121 return Err(serde::de::Error::duplicate_field("heartBeat"));
11122 }
11123 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
11124;
11125 }
11126 }
11127 }
11128 Ok(ReportCompactionTaskRequest {
11129 event: event__,
11130 })
11131 }
11132 }
11133 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
11134 }
11135}
11136impl serde::Serialize for report_compaction_task_request::HeartBeat {
11137 #[allow(deprecated)]
11138 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11139 where
11140 S: serde::Serializer,
11141 {
11142 use serde::ser::SerializeStruct;
11143 let mut len = 0;
11144 if !self.progress.is_empty() {
11145 len += 1;
11146 }
11147 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
11148 if !self.progress.is_empty() {
11149 struct_ser.serialize_field("progress", &self.progress)?;
11150 }
11151 struct_ser.end()
11152 }
11153}
11154impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
11155 #[allow(deprecated)]
11156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11157 where
11158 D: serde::Deserializer<'de>,
11159 {
11160 const FIELDS: &[&str] = &[
11161 "progress",
11162 ];
11163
11164 #[allow(clippy::enum_variant_names)]
11165 enum GeneratedField {
11166 Progress,
11167 }
11168 impl<'de> serde::Deserialize<'de> for GeneratedField {
11169 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11170 where
11171 D: serde::Deserializer<'de>,
11172 {
11173 struct GeneratedVisitor;
11174
11175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11176 type Value = GeneratedField;
11177
11178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11179 write!(formatter, "expected one of: {:?}", &FIELDS)
11180 }
11181
11182 #[allow(unused_variables)]
11183 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11184 where
11185 E: serde::de::Error,
11186 {
11187 match value {
11188 "progress" => Ok(GeneratedField::Progress),
11189 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11190 }
11191 }
11192 }
11193 deserializer.deserialize_identifier(GeneratedVisitor)
11194 }
11195 }
11196 struct GeneratedVisitor;
11197 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11198 type Value = report_compaction_task_request::HeartBeat;
11199
11200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11201 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
11202 }
11203
11204 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
11205 where
11206 V: serde::de::MapAccess<'de>,
11207 {
11208 let mut progress__ = None;
11209 while let Some(k) = map_.next_key()? {
11210 match k {
11211 GeneratedField::Progress => {
11212 if progress__.is_some() {
11213 return Err(serde::de::Error::duplicate_field("progress"));
11214 }
11215 progress__ = Some(map_.next_value()?);
11216 }
11217 }
11218 }
11219 Ok(report_compaction_task_request::HeartBeat {
11220 progress: progress__.unwrap_or_default(),
11221 })
11222 }
11223 }
11224 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
11225 }
11226}
11227impl serde::Serialize for report_compaction_task_request::ReportTask {
11228 #[allow(deprecated)]
11229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11230 where
11231 S: serde::Serializer,
11232 {
11233 use serde::ser::SerializeStruct;
11234 let mut len = 0;
11235 if self.compact_task.is_some() {
11236 len += 1;
11237 }
11238 if !self.table_stats_change.is_empty() {
11239 len += 1;
11240 }
11241 if !self.object_timestamps.is_empty() {
11242 len += 1;
11243 }
11244 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
11245 if let Some(v) = self.compact_task.as_ref() {
11246 struct_ser.serialize_field("compactTask", v)?;
11247 }
11248 if !self.table_stats_change.is_empty() {
11249 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
11250 }
11251 if !self.object_timestamps.is_empty() {
11252 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
11253 .map(|(k, v)| (k, v.to_string())).collect();
11254 struct_ser.serialize_field("objectTimestamps", &v)?;
11255 }
11256 struct_ser.end()
11257 }
11258}
11259impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
11260 #[allow(deprecated)]
11261 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11262 where
11263 D: serde::Deserializer<'de>,
11264 {
11265 const FIELDS: &[&str] = &[
11266 "compact_task",
11267 "compactTask",
11268 "table_stats_change",
11269 "tableStatsChange",
11270 "object_timestamps",
11271 "objectTimestamps",
11272 ];
11273
11274 #[allow(clippy::enum_variant_names)]
11275 enum GeneratedField {
11276 CompactTask,
11277 TableStatsChange,
11278 ObjectTimestamps,
11279 }
11280 impl<'de> serde::Deserialize<'de> for GeneratedField {
11281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11282 where
11283 D: serde::Deserializer<'de>,
11284 {
11285 struct GeneratedVisitor;
11286
11287 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11288 type Value = GeneratedField;
11289
11290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11291 write!(formatter, "expected one of: {:?}", &FIELDS)
11292 }
11293
11294 #[allow(unused_variables)]
11295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11296 where
11297 E: serde::de::Error,
11298 {
11299 match value {
11300 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
11301 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
11302 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
11303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11304 }
11305 }
11306 }
11307 deserializer.deserialize_identifier(GeneratedVisitor)
11308 }
11309 }
11310 struct GeneratedVisitor;
11311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11312 type Value = report_compaction_task_request::ReportTask;
11313
11314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11315 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
11316 }
11317
11318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
11319 where
11320 V: serde::de::MapAccess<'de>,
11321 {
11322 let mut compact_task__ = None;
11323 let mut table_stats_change__ = None;
11324 let mut object_timestamps__ = None;
11325 while let Some(k) = map_.next_key()? {
11326 match k {
11327 GeneratedField::CompactTask => {
11328 if compact_task__.is_some() {
11329 return Err(serde::de::Error::duplicate_field("compactTask"));
11330 }
11331 compact_task__ = map_.next_value()?;
11332 }
11333 GeneratedField::TableStatsChange => {
11334 if table_stats_change__.is_some() {
11335 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
11336 }
11337 table_stats_change__ = Some(
11338 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11339 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11340 );
11341 }
11342 GeneratedField::ObjectTimestamps => {
11343 if object_timestamps__.is_some() {
11344 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
11345 }
11346 object_timestamps__ = Some(
11347 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
11348 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
11349 );
11350 }
11351 }
11352 }
11353 Ok(report_compaction_task_request::ReportTask {
11354 compact_task: compact_task__,
11355 table_stats_change: table_stats_change__.unwrap_or_default(),
11356 object_timestamps: object_timestamps__.unwrap_or_default(),
11357 })
11358 }
11359 }
11360 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
11361 }
11362}
11363impl serde::Serialize for ReportCompactionTaskResponse {
11364 #[allow(deprecated)]
11365 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11366 where
11367 S: serde::Serializer,
11368 {
11369 use serde::ser::SerializeStruct;
11370 let mut len = 0;
11371 if self.status.is_some() {
11372 len += 1;
11373 }
11374 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
11375 if let Some(v) = self.status.as_ref() {
11376 struct_ser.serialize_field("status", v)?;
11377 }
11378 struct_ser.end()
11379 }
11380}
11381impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
11382 #[allow(deprecated)]
11383 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11384 where
11385 D: serde::Deserializer<'de>,
11386 {
11387 const FIELDS: &[&str] = &[
11388 "status",
11389 ];
11390
11391 #[allow(clippy::enum_variant_names)]
11392 enum GeneratedField {
11393 Status,
11394 }
11395 impl<'de> serde::Deserialize<'de> for GeneratedField {
11396 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11397 where
11398 D: serde::Deserializer<'de>,
11399 {
11400 struct GeneratedVisitor;
11401
11402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11403 type Value = GeneratedField;
11404
11405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11406 write!(formatter, "expected one of: {:?}", &FIELDS)
11407 }
11408
11409 #[allow(unused_variables)]
11410 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11411 where
11412 E: serde::de::Error,
11413 {
11414 match value {
11415 "status" => Ok(GeneratedField::Status),
11416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11417 }
11418 }
11419 }
11420 deserializer.deserialize_identifier(GeneratedVisitor)
11421 }
11422 }
11423 struct GeneratedVisitor;
11424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11425 type Value = ReportCompactionTaskResponse;
11426
11427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11428 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
11429 }
11430
11431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
11432 where
11433 V: serde::de::MapAccess<'de>,
11434 {
11435 let mut status__ = None;
11436 while let Some(k) = map_.next_key()? {
11437 match k {
11438 GeneratedField::Status => {
11439 if status__.is_some() {
11440 return Err(serde::de::Error::duplicate_field("status"));
11441 }
11442 status__ = map_.next_value()?;
11443 }
11444 }
11445 }
11446 Ok(ReportCompactionTaskResponse {
11447 status: status__,
11448 })
11449 }
11450 }
11451 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
11452 }
11453}
11454impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
11455 #[allow(deprecated)]
11456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11457 where
11458 S: serde::Serializer,
11459 {
11460 use serde::ser::SerializeStruct;
11461 let len = 0;
11462 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
11463 struct_ser.end()
11464 }
11465}
11466impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
11467 #[allow(deprecated)]
11468 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11469 where
11470 D: serde::Deserializer<'de>,
11471 {
11472 const FIELDS: &[&str] = &[
11473 ];
11474
11475 #[allow(clippy::enum_variant_names)]
11476 enum GeneratedField {
11477 }
11478 impl<'de> serde::Deserialize<'de> for GeneratedField {
11479 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11480 where
11481 D: serde::Deserializer<'de>,
11482 {
11483 struct GeneratedVisitor;
11484
11485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11486 type Value = GeneratedField;
11487
11488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11489 write!(formatter, "expected one of: {:?}", &FIELDS)
11490 }
11491
11492 #[allow(unused_variables)]
11493 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11494 where
11495 E: serde::de::Error,
11496 {
11497 Err(serde::de::Error::unknown_field(value, FIELDS))
11498 }
11499 }
11500 deserializer.deserialize_identifier(GeneratedVisitor)
11501 }
11502 }
11503 struct GeneratedVisitor;
11504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11505 type Value = RiseCtlGetCheckpointVersionRequest;
11506
11507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11508 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
11509 }
11510
11511 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
11512 where
11513 V: serde::de::MapAccess<'de>,
11514 {
11515 while map_.next_key::<GeneratedField>()?.is_some() {
11516 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11517 }
11518 Ok(RiseCtlGetCheckpointVersionRequest {
11519 })
11520 }
11521 }
11522 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
11523 }
11524}
11525impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
11526 #[allow(deprecated)]
11527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11528 where
11529 S: serde::Serializer,
11530 {
11531 use serde::ser::SerializeStruct;
11532 let mut len = 0;
11533 if self.checkpoint_version.is_some() {
11534 len += 1;
11535 }
11536 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
11537 if let Some(v) = self.checkpoint_version.as_ref() {
11538 struct_ser.serialize_field("checkpointVersion", v)?;
11539 }
11540 struct_ser.end()
11541 }
11542}
11543impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
11544 #[allow(deprecated)]
11545 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11546 where
11547 D: serde::Deserializer<'de>,
11548 {
11549 const FIELDS: &[&str] = &[
11550 "checkpoint_version",
11551 "checkpointVersion",
11552 ];
11553
11554 #[allow(clippy::enum_variant_names)]
11555 enum GeneratedField {
11556 CheckpointVersion,
11557 }
11558 impl<'de> serde::Deserialize<'de> for GeneratedField {
11559 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11560 where
11561 D: serde::Deserializer<'de>,
11562 {
11563 struct GeneratedVisitor;
11564
11565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11566 type Value = GeneratedField;
11567
11568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11569 write!(formatter, "expected one of: {:?}", &FIELDS)
11570 }
11571
11572 #[allow(unused_variables)]
11573 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11574 where
11575 E: serde::de::Error,
11576 {
11577 match value {
11578 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
11579 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11580 }
11581 }
11582 }
11583 deserializer.deserialize_identifier(GeneratedVisitor)
11584 }
11585 }
11586 struct GeneratedVisitor;
11587 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11588 type Value = RiseCtlGetCheckpointVersionResponse;
11589
11590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11591 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
11592 }
11593
11594 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
11595 where
11596 V: serde::de::MapAccess<'de>,
11597 {
11598 let mut checkpoint_version__ = None;
11599 while let Some(k) = map_.next_key()? {
11600 match k {
11601 GeneratedField::CheckpointVersion => {
11602 if checkpoint_version__.is_some() {
11603 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
11604 }
11605 checkpoint_version__ = map_.next_value()?;
11606 }
11607 }
11608 }
11609 Ok(RiseCtlGetCheckpointVersionResponse {
11610 checkpoint_version: checkpoint_version__,
11611 })
11612 }
11613 }
11614 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
11615 }
11616}
11617impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
11618 #[allow(deprecated)]
11619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11620 where
11621 S: serde::Serializer,
11622 {
11623 use serde::ser::SerializeStruct;
11624 let len = 0;
11625 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
11626 struct_ser.end()
11627 }
11628}
11629impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
11630 #[allow(deprecated)]
11631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11632 where
11633 D: serde::Deserializer<'de>,
11634 {
11635 const FIELDS: &[&str] = &[
11636 ];
11637
11638 #[allow(clippy::enum_variant_names)]
11639 enum GeneratedField {
11640 }
11641 impl<'de> serde::Deserialize<'de> for GeneratedField {
11642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11643 where
11644 D: serde::Deserializer<'de>,
11645 {
11646 struct GeneratedVisitor;
11647
11648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11649 type Value = GeneratedField;
11650
11651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11652 write!(formatter, "expected one of: {:?}", &FIELDS)
11653 }
11654
11655 #[allow(unused_variables)]
11656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11657 where
11658 E: serde::de::Error,
11659 {
11660 Err(serde::de::Error::unknown_field(value, FIELDS))
11661 }
11662 }
11663 deserializer.deserialize_identifier(GeneratedVisitor)
11664 }
11665 }
11666 struct GeneratedVisitor;
11667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11668 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
11669
11670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11671 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
11672 }
11673
11674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
11675 where
11676 V: serde::de::MapAccess<'de>,
11677 {
11678 while map_.next_key::<GeneratedField>()?.is_some() {
11679 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11680 }
11681 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
11682 })
11683 }
11684 }
11685 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
11686 }
11687}
11688impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
11689 #[allow(deprecated)]
11690 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11691 where
11692 S: serde::Serializer,
11693 {
11694 use serde::ser::SerializeStruct;
11695 let mut len = 0;
11696 if self.summary.is_some() {
11697 len += 1;
11698 }
11699 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
11700 if let Some(v) = self.summary.as_ref() {
11701 struct_ser.serialize_field("summary", v)?;
11702 }
11703 struct_ser.end()
11704 }
11705}
11706impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
11707 #[allow(deprecated)]
11708 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11709 where
11710 D: serde::Deserializer<'de>,
11711 {
11712 const FIELDS: &[&str] = &[
11713 "summary",
11714 ];
11715
11716 #[allow(clippy::enum_variant_names)]
11717 enum GeneratedField {
11718 Summary,
11719 }
11720 impl<'de> serde::Deserialize<'de> for GeneratedField {
11721 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11722 where
11723 D: serde::Deserializer<'de>,
11724 {
11725 struct GeneratedVisitor;
11726
11727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11728 type Value = GeneratedField;
11729
11730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11731 write!(formatter, "expected one of: {:?}", &FIELDS)
11732 }
11733
11734 #[allow(unused_variables)]
11735 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11736 where
11737 E: serde::de::Error,
11738 {
11739 match value {
11740 "summary" => Ok(GeneratedField::Summary),
11741 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11742 }
11743 }
11744 }
11745 deserializer.deserialize_identifier(GeneratedVisitor)
11746 }
11747 }
11748 struct GeneratedVisitor;
11749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11750 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
11751
11752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11753 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
11754 }
11755
11756 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
11757 where
11758 V: serde::de::MapAccess<'de>,
11759 {
11760 let mut summary__ = None;
11761 while let Some(k) = map_.next_key()? {
11762 match k {
11763 GeneratedField::Summary => {
11764 if summary__.is_some() {
11765 return Err(serde::de::Error::duplicate_field("summary"));
11766 }
11767 summary__ = map_.next_value()?;
11768 }
11769 }
11770 }
11771 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
11772 summary: summary__,
11773 })
11774 }
11775 }
11776 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
11777 }
11778}
11779impl serde::Serialize for RiseCtlListCompactionGroupRequest {
11780 #[allow(deprecated)]
11781 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11782 where
11783 S: serde::Serializer,
11784 {
11785 use serde::ser::SerializeStruct;
11786 let len = 0;
11787 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
11788 struct_ser.end()
11789 }
11790}
11791impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
11792 #[allow(deprecated)]
11793 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11794 where
11795 D: serde::Deserializer<'de>,
11796 {
11797 const FIELDS: &[&str] = &[
11798 ];
11799
11800 #[allow(clippy::enum_variant_names)]
11801 enum GeneratedField {
11802 }
11803 impl<'de> serde::Deserialize<'de> for GeneratedField {
11804 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11805 where
11806 D: serde::Deserializer<'de>,
11807 {
11808 struct GeneratedVisitor;
11809
11810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11811 type Value = GeneratedField;
11812
11813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11814 write!(formatter, "expected one of: {:?}", &FIELDS)
11815 }
11816
11817 #[allow(unused_variables)]
11818 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11819 where
11820 E: serde::de::Error,
11821 {
11822 Err(serde::de::Error::unknown_field(value, FIELDS))
11823 }
11824 }
11825 deserializer.deserialize_identifier(GeneratedVisitor)
11826 }
11827 }
11828 struct GeneratedVisitor;
11829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11830 type Value = RiseCtlListCompactionGroupRequest;
11831
11832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11833 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
11834 }
11835
11836 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
11837 where
11838 V: serde::de::MapAccess<'de>,
11839 {
11840 while map_.next_key::<GeneratedField>()?.is_some() {
11841 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11842 }
11843 Ok(RiseCtlListCompactionGroupRequest {
11844 })
11845 }
11846 }
11847 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
11848 }
11849}
11850impl serde::Serialize for RiseCtlListCompactionGroupResponse {
11851 #[allow(deprecated)]
11852 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11853 where
11854 S: serde::Serializer,
11855 {
11856 use serde::ser::SerializeStruct;
11857 let mut len = 0;
11858 if self.status.is_some() {
11859 len += 1;
11860 }
11861 if !self.compaction_groups.is_empty() {
11862 len += 1;
11863 }
11864 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
11865 if let Some(v) = self.status.as_ref() {
11866 struct_ser.serialize_field("status", v)?;
11867 }
11868 if !self.compaction_groups.is_empty() {
11869 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
11870 }
11871 struct_ser.end()
11872 }
11873}
11874impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
11875 #[allow(deprecated)]
11876 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11877 where
11878 D: serde::Deserializer<'de>,
11879 {
11880 const FIELDS: &[&str] = &[
11881 "status",
11882 "compaction_groups",
11883 "compactionGroups",
11884 ];
11885
11886 #[allow(clippy::enum_variant_names)]
11887 enum GeneratedField {
11888 Status,
11889 CompactionGroups,
11890 }
11891 impl<'de> serde::Deserialize<'de> for GeneratedField {
11892 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11893 where
11894 D: serde::Deserializer<'de>,
11895 {
11896 struct GeneratedVisitor;
11897
11898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11899 type Value = GeneratedField;
11900
11901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11902 write!(formatter, "expected one of: {:?}", &FIELDS)
11903 }
11904
11905 #[allow(unused_variables)]
11906 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11907 where
11908 E: serde::de::Error,
11909 {
11910 match value {
11911 "status" => Ok(GeneratedField::Status),
11912 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
11913 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11914 }
11915 }
11916 }
11917 deserializer.deserialize_identifier(GeneratedVisitor)
11918 }
11919 }
11920 struct GeneratedVisitor;
11921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11922 type Value = RiseCtlListCompactionGroupResponse;
11923
11924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11925 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
11926 }
11927
11928 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
11929 where
11930 V: serde::de::MapAccess<'de>,
11931 {
11932 let mut status__ = None;
11933 let mut compaction_groups__ = None;
11934 while let Some(k) = map_.next_key()? {
11935 match k {
11936 GeneratedField::Status => {
11937 if status__.is_some() {
11938 return Err(serde::de::Error::duplicate_field("status"));
11939 }
11940 status__ = map_.next_value()?;
11941 }
11942 GeneratedField::CompactionGroups => {
11943 if compaction_groups__.is_some() {
11944 return Err(serde::de::Error::duplicate_field("compactionGroups"));
11945 }
11946 compaction_groups__ = Some(map_.next_value()?);
11947 }
11948 }
11949 }
11950 Ok(RiseCtlListCompactionGroupResponse {
11951 status: status__,
11952 compaction_groups: compaction_groups__.unwrap_or_default(),
11953 })
11954 }
11955 }
11956 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
11957 }
11958}
11959impl serde::Serialize for RiseCtlListCompactionStatusRequest {
11960 #[allow(deprecated)]
11961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11962 where
11963 S: serde::Serializer,
11964 {
11965 use serde::ser::SerializeStruct;
11966 let len = 0;
11967 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
11968 struct_ser.end()
11969 }
11970}
11971impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
11972 #[allow(deprecated)]
11973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11974 where
11975 D: serde::Deserializer<'de>,
11976 {
11977 const FIELDS: &[&str] = &[
11978 ];
11979
11980 #[allow(clippy::enum_variant_names)]
11981 enum GeneratedField {
11982 }
11983 impl<'de> serde::Deserialize<'de> for GeneratedField {
11984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11985 where
11986 D: serde::Deserializer<'de>,
11987 {
11988 struct GeneratedVisitor;
11989
11990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11991 type Value = GeneratedField;
11992
11993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11994 write!(formatter, "expected one of: {:?}", &FIELDS)
11995 }
11996
11997 #[allow(unused_variables)]
11998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11999 where
12000 E: serde::de::Error,
12001 {
12002 Err(serde::de::Error::unknown_field(value, FIELDS))
12003 }
12004 }
12005 deserializer.deserialize_identifier(GeneratedVisitor)
12006 }
12007 }
12008 struct GeneratedVisitor;
12009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12010 type Value = RiseCtlListCompactionStatusRequest;
12011
12012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12013 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
12014 }
12015
12016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
12017 where
12018 V: serde::de::MapAccess<'de>,
12019 {
12020 while map_.next_key::<GeneratedField>()?.is_some() {
12021 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12022 }
12023 Ok(RiseCtlListCompactionStatusRequest {
12024 })
12025 }
12026 }
12027 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
12028 }
12029}
12030impl serde::Serialize for RiseCtlListCompactionStatusResponse {
12031 #[allow(deprecated)]
12032 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12033 where
12034 S: serde::Serializer,
12035 {
12036 use serde::ser::SerializeStruct;
12037 let mut len = 0;
12038 if !self.compaction_statuses.is_empty() {
12039 len += 1;
12040 }
12041 if !self.task_assignment.is_empty() {
12042 len += 1;
12043 }
12044 if !self.task_progress.is_empty() {
12045 len += 1;
12046 }
12047 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
12048 if !self.compaction_statuses.is_empty() {
12049 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
12050 }
12051 if !self.task_assignment.is_empty() {
12052 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
12053 }
12054 if !self.task_progress.is_empty() {
12055 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
12056 }
12057 struct_ser.end()
12058 }
12059}
12060impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
12061 #[allow(deprecated)]
12062 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12063 where
12064 D: serde::Deserializer<'de>,
12065 {
12066 const FIELDS: &[&str] = &[
12067 "compaction_statuses",
12068 "compactionStatuses",
12069 "task_assignment",
12070 "taskAssignment",
12071 "task_progress",
12072 "taskProgress",
12073 ];
12074
12075 #[allow(clippy::enum_variant_names)]
12076 enum GeneratedField {
12077 CompactionStatuses,
12078 TaskAssignment,
12079 TaskProgress,
12080 }
12081 impl<'de> serde::Deserialize<'de> for GeneratedField {
12082 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12083 where
12084 D: serde::Deserializer<'de>,
12085 {
12086 struct GeneratedVisitor;
12087
12088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12089 type Value = GeneratedField;
12090
12091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12092 write!(formatter, "expected one of: {:?}", &FIELDS)
12093 }
12094
12095 #[allow(unused_variables)]
12096 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12097 where
12098 E: serde::de::Error,
12099 {
12100 match value {
12101 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
12102 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
12103 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
12104 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12105 }
12106 }
12107 }
12108 deserializer.deserialize_identifier(GeneratedVisitor)
12109 }
12110 }
12111 struct GeneratedVisitor;
12112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12113 type Value = RiseCtlListCompactionStatusResponse;
12114
12115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12116 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
12117 }
12118
12119 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
12120 where
12121 V: serde::de::MapAccess<'de>,
12122 {
12123 let mut compaction_statuses__ = None;
12124 let mut task_assignment__ = None;
12125 let mut task_progress__ = None;
12126 while let Some(k) = map_.next_key()? {
12127 match k {
12128 GeneratedField::CompactionStatuses => {
12129 if compaction_statuses__.is_some() {
12130 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
12131 }
12132 compaction_statuses__ = Some(map_.next_value()?);
12133 }
12134 GeneratedField::TaskAssignment => {
12135 if task_assignment__.is_some() {
12136 return Err(serde::de::Error::duplicate_field("taskAssignment"));
12137 }
12138 task_assignment__ = Some(map_.next_value()?);
12139 }
12140 GeneratedField::TaskProgress => {
12141 if task_progress__.is_some() {
12142 return Err(serde::de::Error::duplicate_field("taskProgress"));
12143 }
12144 task_progress__ = Some(map_.next_value()?);
12145 }
12146 }
12147 }
12148 Ok(RiseCtlListCompactionStatusResponse {
12149 compaction_statuses: compaction_statuses__.unwrap_or_default(),
12150 task_assignment: task_assignment__.unwrap_or_default(),
12151 task_progress: task_progress__.unwrap_or_default(),
12152 })
12153 }
12154 }
12155 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
12156 }
12157}
12158impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
12159 #[allow(deprecated)]
12160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12161 where
12162 S: serde::Serializer,
12163 {
12164 use serde::ser::SerializeStruct;
12165 let len = 0;
12166 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
12167 struct_ser.end()
12168 }
12169}
12170impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
12171 #[allow(deprecated)]
12172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12173 where
12174 D: serde::Deserializer<'de>,
12175 {
12176 const FIELDS: &[&str] = &[
12177 ];
12178
12179 #[allow(clippy::enum_variant_names)]
12180 enum GeneratedField {
12181 }
12182 impl<'de> serde::Deserialize<'de> for GeneratedField {
12183 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12184 where
12185 D: serde::Deserializer<'de>,
12186 {
12187 struct GeneratedVisitor;
12188
12189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12190 type Value = GeneratedField;
12191
12192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12193 write!(formatter, "expected one of: {:?}", &FIELDS)
12194 }
12195
12196 #[allow(unused_variables)]
12197 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12198 where
12199 E: serde::de::Error,
12200 {
12201 Err(serde::de::Error::unknown_field(value, FIELDS))
12202 }
12203 }
12204 deserializer.deserialize_identifier(GeneratedVisitor)
12205 }
12206 }
12207 struct GeneratedVisitor;
12208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12209 type Value = RiseCtlPauseVersionCheckpointRequest;
12210
12211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12212 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
12213 }
12214
12215 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
12216 where
12217 V: serde::de::MapAccess<'de>,
12218 {
12219 while map_.next_key::<GeneratedField>()?.is_some() {
12220 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12221 }
12222 Ok(RiseCtlPauseVersionCheckpointRequest {
12223 })
12224 }
12225 }
12226 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12227 }
12228}
12229impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
12230 #[allow(deprecated)]
12231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12232 where
12233 S: serde::Serializer,
12234 {
12235 use serde::ser::SerializeStruct;
12236 let len = 0;
12237 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
12238 struct_ser.end()
12239 }
12240}
12241impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
12242 #[allow(deprecated)]
12243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12244 where
12245 D: serde::Deserializer<'de>,
12246 {
12247 const FIELDS: &[&str] = &[
12248 ];
12249
12250 #[allow(clippy::enum_variant_names)]
12251 enum GeneratedField {
12252 }
12253 impl<'de> serde::Deserialize<'de> for GeneratedField {
12254 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12255 where
12256 D: serde::Deserializer<'de>,
12257 {
12258 struct GeneratedVisitor;
12259
12260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12261 type Value = GeneratedField;
12262
12263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12264 write!(formatter, "expected one of: {:?}", &FIELDS)
12265 }
12266
12267 #[allow(unused_variables)]
12268 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12269 where
12270 E: serde::de::Error,
12271 {
12272 Err(serde::de::Error::unknown_field(value, FIELDS))
12273 }
12274 }
12275 deserializer.deserialize_identifier(GeneratedVisitor)
12276 }
12277 }
12278 struct GeneratedVisitor;
12279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12280 type Value = RiseCtlPauseVersionCheckpointResponse;
12281
12282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12283 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
12284 }
12285
12286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
12287 where
12288 V: serde::de::MapAccess<'de>,
12289 {
12290 while map_.next_key::<GeneratedField>()?.is_some() {
12291 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12292 }
12293 Ok(RiseCtlPauseVersionCheckpointResponse {
12294 })
12295 }
12296 }
12297 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
12298 }
12299}
12300impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
12301 #[allow(deprecated)]
12302 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12303 where
12304 S: serde::Serializer,
12305 {
12306 use serde::ser::SerializeStruct;
12307 let len = 0;
12308 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
12309 struct_ser.end()
12310 }
12311}
12312impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
12313 #[allow(deprecated)]
12314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12315 where
12316 D: serde::Deserializer<'de>,
12317 {
12318 const FIELDS: &[&str] = &[
12319 ];
12320
12321 #[allow(clippy::enum_variant_names)]
12322 enum GeneratedField {
12323 }
12324 impl<'de> serde::Deserialize<'de> for GeneratedField {
12325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12326 where
12327 D: serde::Deserializer<'de>,
12328 {
12329 struct GeneratedVisitor;
12330
12331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12332 type Value = GeneratedField;
12333
12334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12335 write!(formatter, "expected one of: {:?}", &FIELDS)
12336 }
12337
12338 #[allow(unused_variables)]
12339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12340 where
12341 E: serde::de::Error,
12342 {
12343 Err(serde::de::Error::unknown_field(value, FIELDS))
12344 }
12345 }
12346 deserializer.deserialize_identifier(GeneratedVisitor)
12347 }
12348 }
12349 struct GeneratedVisitor;
12350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12351 type Value = RiseCtlRebuildTableStatsRequest;
12352
12353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12354 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
12355 }
12356
12357 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
12358 where
12359 V: serde::de::MapAccess<'de>,
12360 {
12361 while map_.next_key::<GeneratedField>()?.is_some() {
12362 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12363 }
12364 Ok(RiseCtlRebuildTableStatsRequest {
12365 })
12366 }
12367 }
12368 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
12369 }
12370}
12371impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
12372 #[allow(deprecated)]
12373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12374 where
12375 S: serde::Serializer,
12376 {
12377 use serde::ser::SerializeStruct;
12378 let len = 0;
12379 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
12380 struct_ser.end()
12381 }
12382}
12383impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
12384 #[allow(deprecated)]
12385 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12386 where
12387 D: serde::Deserializer<'de>,
12388 {
12389 const FIELDS: &[&str] = &[
12390 ];
12391
12392 #[allow(clippy::enum_variant_names)]
12393 enum GeneratedField {
12394 }
12395 impl<'de> serde::Deserialize<'de> for GeneratedField {
12396 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12397 where
12398 D: serde::Deserializer<'de>,
12399 {
12400 struct GeneratedVisitor;
12401
12402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12403 type Value = GeneratedField;
12404
12405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12406 write!(formatter, "expected one of: {:?}", &FIELDS)
12407 }
12408
12409 #[allow(unused_variables)]
12410 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12411 where
12412 E: serde::de::Error,
12413 {
12414 Err(serde::de::Error::unknown_field(value, FIELDS))
12415 }
12416 }
12417 deserializer.deserialize_identifier(GeneratedVisitor)
12418 }
12419 }
12420 struct GeneratedVisitor;
12421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12422 type Value = RiseCtlRebuildTableStatsResponse;
12423
12424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12425 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
12426 }
12427
12428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
12429 where
12430 V: serde::de::MapAccess<'de>,
12431 {
12432 while map_.next_key::<GeneratedField>()?.is_some() {
12433 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12434 }
12435 Ok(RiseCtlRebuildTableStatsResponse {
12436 })
12437 }
12438 }
12439 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
12440 }
12441}
12442impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
12443 #[allow(deprecated)]
12444 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12445 where
12446 S: serde::Serializer,
12447 {
12448 use serde::ser::SerializeStruct;
12449 let len = 0;
12450 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
12451 struct_ser.end()
12452 }
12453}
12454impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
12455 #[allow(deprecated)]
12456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12457 where
12458 D: serde::Deserializer<'de>,
12459 {
12460 const FIELDS: &[&str] = &[
12461 ];
12462
12463 #[allow(clippy::enum_variant_names)]
12464 enum GeneratedField {
12465 }
12466 impl<'de> serde::Deserialize<'de> for GeneratedField {
12467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12468 where
12469 D: serde::Deserializer<'de>,
12470 {
12471 struct GeneratedVisitor;
12472
12473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12474 type Value = GeneratedField;
12475
12476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12477 write!(formatter, "expected one of: {:?}", &FIELDS)
12478 }
12479
12480 #[allow(unused_variables)]
12481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12482 where
12483 E: serde::de::Error,
12484 {
12485 Err(serde::de::Error::unknown_field(value, FIELDS))
12486 }
12487 }
12488 deserializer.deserialize_identifier(GeneratedVisitor)
12489 }
12490 }
12491 struct GeneratedVisitor;
12492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12493 type Value = RiseCtlResumeVersionCheckpointRequest;
12494
12495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12496 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
12497 }
12498
12499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
12500 where
12501 V: serde::de::MapAccess<'de>,
12502 {
12503 while map_.next_key::<GeneratedField>()?.is_some() {
12504 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12505 }
12506 Ok(RiseCtlResumeVersionCheckpointRequest {
12507 })
12508 }
12509 }
12510 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12511 }
12512}
12513impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
12514 #[allow(deprecated)]
12515 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12516 where
12517 S: serde::Serializer,
12518 {
12519 use serde::ser::SerializeStruct;
12520 let len = 0;
12521 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
12522 struct_ser.end()
12523 }
12524}
12525impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
12526 #[allow(deprecated)]
12527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12528 where
12529 D: serde::Deserializer<'de>,
12530 {
12531 const FIELDS: &[&str] = &[
12532 ];
12533
12534 #[allow(clippy::enum_variant_names)]
12535 enum GeneratedField {
12536 }
12537 impl<'de> serde::Deserialize<'de> for GeneratedField {
12538 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12539 where
12540 D: serde::Deserializer<'de>,
12541 {
12542 struct GeneratedVisitor;
12543
12544 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12545 type Value = GeneratedField;
12546
12547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12548 write!(formatter, "expected one of: {:?}", &FIELDS)
12549 }
12550
12551 #[allow(unused_variables)]
12552 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12553 where
12554 E: serde::de::Error,
12555 {
12556 Err(serde::de::Error::unknown_field(value, FIELDS))
12557 }
12558 }
12559 deserializer.deserialize_identifier(GeneratedVisitor)
12560 }
12561 }
12562 struct GeneratedVisitor;
12563 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12564 type Value = RiseCtlResumeVersionCheckpointResponse;
12565
12566 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12567 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
12568 }
12569
12570 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
12571 where
12572 V: serde::de::MapAccess<'de>,
12573 {
12574 while map_.next_key::<GeneratedField>()?.is_some() {
12575 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12576 }
12577 Ok(RiseCtlResumeVersionCheckpointResponse {
12578 })
12579 }
12580 }
12581 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
12582 }
12583}
12584impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
12585 #[allow(deprecated)]
12586 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12587 where
12588 S: serde::Serializer,
12589 {
12590 use serde::ser::SerializeStruct;
12591 let mut len = 0;
12592 if !self.compaction_group_ids.is_empty() {
12593 len += 1;
12594 }
12595 if !self.configs.is_empty() {
12596 len += 1;
12597 }
12598 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
12599 if !self.compaction_group_ids.is_empty() {
12600 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
12601 }
12602 if !self.configs.is_empty() {
12603 struct_ser.serialize_field("configs", &self.configs)?;
12604 }
12605 struct_ser.end()
12606 }
12607}
12608impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
12609 #[allow(deprecated)]
12610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12611 where
12612 D: serde::Deserializer<'de>,
12613 {
12614 const FIELDS: &[&str] = &[
12615 "compaction_group_ids",
12616 "compactionGroupIds",
12617 "configs",
12618 ];
12619
12620 #[allow(clippy::enum_variant_names)]
12621 enum GeneratedField {
12622 CompactionGroupIds,
12623 Configs,
12624 }
12625 impl<'de> serde::Deserialize<'de> for GeneratedField {
12626 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12627 where
12628 D: serde::Deserializer<'de>,
12629 {
12630 struct GeneratedVisitor;
12631
12632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12633 type Value = GeneratedField;
12634
12635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12636 write!(formatter, "expected one of: {:?}", &FIELDS)
12637 }
12638
12639 #[allow(unused_variables)]
12640 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12641 where
12642 E: serde::de::Error,
12643 {
12644 match value {
12645 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
12646 "configs" => Ok(GeneratedField::Configs),
12647 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12648 }
12649 }
12650 }
12651 deserializer.deserialize_identifier(GeneratedVisitor)
12652 }
12653 }
12654 struct GeneratedVisitor;
12655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12656 type Value = RiseCtlUpdateCompactionConfigRequest;
12657
12658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12659 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
12660 }
12661
12662 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
12663 where
12664 V: serde::de::MapAccess<'de>,
12665 {
12666 let mut compaction_group_ids__ = None;
12667 let mut configs__ = None;
12668 while let Some(k) = map_.next_key()? {
12669 match k {
12670 GeneratedField::CompactionGroupIds => {
12671 if compaction_group_ids__.is_some() {
12672 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
12673 }
12674 compaction_group_ids__ =
12675 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12676 .into_iter().map(|x| x.0).collect())
12677 ;
12678 }
12679 GeneratedField::Configs => {
12680 if configs__.is_some() {
12681 return Err(serde::de::Error::duplicate_field("configs"));
12682 }
12683 configs__ = Some(map_.next_value()?);
12684 }
12685 }
12686 }
12687 Ok(RiseCtlUpdateCompactionConfigRequest {
12688 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
12689 configs: configs__.unwrap_or_default(),
12690 })
12691 }
12692 }
12693 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
12694 }
12695}
12696impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12697 #[allow(deprecated)]
12698 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12699 where
12700 S: serde::Serializer,
12701 {
12702 use serde::ser::SerializeStruct;
12703 let mut len = 0;
12704 if self.level != 0 {
12705 len += 1;
12706 }
12707 if !self.compression_algorithm.is_empty() {
12708 len += 1;
12709 }
12710 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
12711 if self.level != 0 {
12712 struct_ser.serialize_field("level", &self.level)?;
12713 }
12714 if !self.compression_algorithm.is_empty() {
12715 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
12716 }
12717 struct_ser.end()
12718 }
12719}
12720impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12721 #[allow(deprecated)]
12722 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12723 where
12724 D: serde::Deserializer<'de>,
12725 {
12726 const FIELDS: &[&str] = &[
12727 "level",
12728 "compression_algorithm",
12729 "compressionAlgorithm",
12730 ];
12731
12732 #[allow(clippy::enum_variant_names)]
12733 enum GeneratedField {
12734 Level,
12735 CompressionAlgorithm,
12736 }
12737 impl<'de> serde::Deserialize<'de> for GeneratedField {
12738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12739 where
12740 D: serde::Deserializer<'de>,
12741 {
12742 struct GeneratedVisitor;
12743
12744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12745 type Value = GeneratedField;
12746
12747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12748 write!(formatter, "expected one of: {:?}", &FIELDS)
12749 }
12750
12751 #[allow(unused_variables)]
12752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12753 where
12754 E: serde::de::Error,
12755 {
12756 match value {
12757 "level" => Ok(GeneratedField::Level),
12758 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12759 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12760 }
12761 }
12762 }
12763 deserializer.deserialize_identifier(GeneratedVisitor)
12764 }
12765 }
12766 struct GeneratedVisitor;
12767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12768 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
12769
12770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12771 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
12772 }
12773
12774 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
12775 where
12776 V: serde::de::MapAccess<'de>,
12777 {
12778 let mut level__ = None;
12779 let mut compression_algorithm__ = None;
12780 while let Some(k) = map_.next_key()? {
12781 match k {
12782 GeneratedField::Level => {
12783 if level__.is_some() {
12784 return Err(serde::de::Error::duplicate_field("level"));
12785 }
12786 level__ =
12787 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12788 ;
12789 }
12790 GeneratedField::CompressionAlgorithm => {
12791 if compression_algorithm__.is_some() {
12792 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12793 }
12794 compression_algorithm__ = Some(map_.next_value()?);
12795 }
12796 }
12797 }
12798 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12799 level: level__.unwrap_or_default(),
12800 compression_algorithm: compression_algorithm__.unwrap_or_default(),
12801 })
12802 }
12803 }
12804 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
12805 }
12806}
12807impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
12808 #[allow(deprecated)]
12809 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12810 where
12811 S: serde::Serializer,
12812 {
12813 use serde::ser::SerializeStruct;
12814 let mut len = 0;
12815 if self.mutable_config.is_some() {
12816 len += 1;
12817 }
12818 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
12819 if let Some(v) = self.mutable_config.as_ref() {
12820 match v {
12821 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
12822 #[allow(clippy::needless_borrow)]
12823 #[allow(clippy::needless_borrows_for_generic_args)]
12824 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
12825 }
12826 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
12827 #[allow(clippy::needless_borrow)]
12828 #[allow(clippy::needless_borrows_for_generic_args)]
12829 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
12830 }
12831 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
12832 #[allow(clippy::needless_borrow)]
12833 #[allow(clippy::needless_borrows_for_generic_args)]
12834 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
12835 }
12836 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
12837 #[allow(clippy::needless_borrow)]
12838 #[allow(clippy::needless_borrows_for_generic_args)]
12839 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
12840 }
12841 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
12842 #[allow(clippy::needless_borrow)]
12843 #[allow(clippy::needless_borrows_for_generic_args)]
12844 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
12845 }
12846 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
12847 #[allow(clippy::needless_borrow)]
12848 #[allow(clippy::needless_borrows_for_generic_args)]
12849 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
12850 }
12851 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
12852 struct_ser.serialize_field("compactionFilterMask", v)?;
12853 }
12854 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
12855 struct_ser.serialize_field("maxSubCompaction", v)?;
12856 }
12857 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
12858 #[allow(clippy::needless_borrow)]
12859 #[allow(clippy::needless_borrows_for_generic_args)]
12860 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
12861 }
12862 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
12863 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
12864 }
12865 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
12866 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
12867 }
12868 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
12869 #[allow(clippy::needless_borrow)]
12870 #[allow(clippy::needless_borrows_for_generic_args)]
12871 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
12872 }
12873 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
12874 #[allow(clippy::needless_borrow)]
12875 #[allow(clippy::needless_borrows_for_generic_args)]
12876 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
12877 }
12878 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
12879 struct_ser.serialize_field("enableEmergencyPicker", v)?;
12880 }
12881 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
12882 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
12883 }
12884 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
12885 struct_ser.serialize_field("compressionAlgorithm", v)?;
12886 }
12887 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
12888 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
12889 }
12890 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
12891 #[allow(clippy::needless_borrow)]
12892 #[allow(clippy::needless_borrows_for_generic_args)]
12893 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
12894 }
12895 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
12896 struct_ser.serialize_field("splitWeightByVnode", v)?;
12897 }
12898 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
12899 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
12900 }
12901 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
12902 #[allow(clippy::needless_borrow)]
12903 #[allow(clippy::needless_borrows_for_generic_args)]
12904 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
12905 }
12906 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
12907 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
12908 }
12909 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
12910 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
12911 }
12912 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
12913 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
12914 }
12915 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
12916 #[allow(clippy::needless_borrow)]
12917 #[allow(clippy::needless_borrows_for_generic_args)]
12918 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
12919 }
12920 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
12921 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
12922 }
12923 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
12924 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
12925 }
12926 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::VnodeAlignedLevelSizeThreshold(v) => {
12927 #[allow(clippy::needless_borrow)]
12928 #[allow(clippy::needless_borrows_for_generic_args)]
12929 struct_ser.serialize_field("vnodeAlignedLevelSizeThreshold", ToString::to_string(&v).as_str())?;
12930 }
12931 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxKvCountForXor16(v) => {
12932 #[allow(clippy::needless_borrow)]
12933 #[allow(clippy::needless_borrows_for_generic_args)]
12934 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
12935 }
12936 }
12937 }
12938 struct_ser.end()
12939 }
12940}
12941impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
12942 #[allow(deprecated)]
12943 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12944 where
12945 D: serde::Deserializer<'de>,
12946 {
12947 const FIELDS: &[&str] = &[
12948 "max_bytes_for_level_base",
12949 "maxBytesForLevelBase",
12950 "max_bytes_for_level_multiplier",
12951 "maxBytesForLevelMultiplier",
12952 "max_compaction_bytes",
12953 "maxCompactionBytes",
12954 "sub_level_max_compaction_bytes",
12955 "subLevelMaxCompactionBytes",
12956 "level0_tier_compact_file_number",
12957 "level0TierCompactFileNumber",
12958 "target_file_size_base",
12959 "targetFileSizeBase",
12960 "compaction_filter_mask",
12961 "compactionFilterMask",
12962 "max_sub_compaction",
12963 "maxSubCompaction",
12964 "level0_stop_write_threshold_sub_level_number",
12965 "level0StopWriteThresholdSubLevelNumber",
12966 "level0_sub_level_compact_level_count",
12967 "level0SubLevelCompactLevelCount",
12968 "level0_overlapping_sub_level_compact_level_count",
12969 "level0OverlappingSubLevelCompactLevelCount",
12970 "max_space_reclaim_bytes",
12971 "maxSpaceReclaimBytes",
12972 "level0_max_compact_file_number",
12973 "level0MaxCompactFileNumber",
12974 "enable_emergency_picker",
12975 "enableEmergencyPicker",
12976 "tombstone_reclaim_ratio",
12977 "tombstoneReclaimRatio",
12978 "compression_algorithm",
12979 "compressionAlgorithm",
12980 "max_l0_compact_level_count",
12981 "maxL0CompactLevelCount",
12982 "sst_allowed_trivial_move_min_size",
12983 "sstAllowedTrivialMoveMinSize",
12984 "split_weight_by_vnode",
12985 "splitWeightByVnode",
12986 "disable_auto_group_scheduling",
12987 "disableAutoGroupScheduling",
12988 "max_overlapping_level_size",
12989 "maxOverlappingLevelSize",
12990 "emergency_level0_sst_file_count",
12991 "emergencyLevel0SstFileCount",
12992 "emergency_level0_sub_level_partition",
12993 "emergencyLevel0SubLevelPartition",
12994 "level0_stop_write_threshold_max_sst_count",
12995 "level0StopWriteThresholdMaxSstCount",
12996 "level0_stop_write_threshold_max_size",
12997 "level0StopWriteThresholdMaxSize",
12998 "sst_allowed_trivial_move_max_count",
12999 "sstAllowedTrivialMoveMaxCount",
13000 "enable_optimize_l0_interval_selection",
13001 "enableOptimizeL0IntervalSelection",
13002 "vnode_aligned_level_size_threshold",
13003 "vnodeAlignedLevelSizeThreshold",
13004 "max_kv_count_for_xor16",
13005 "maxKvCountForXor16",
13006 ];
13007
13008 #[allow(clippy::enum_variant_names)]
13009 enum GeneratedField {
13010 MaxBytesForLevelBase,
13011 MaxBytesForLevelMultiplier,
13012 MaxCompactionBytes,
13013 SubLevelMaxCompactionBytes,
13014 Level0TierCompactFileNumber,
13015 TargetFileSizeBase,
13016 CompactionFilterMask,
13017 MaxSubCompaction,
13018 Level0StopWriteThresholdSubLevelNumber,
13019 Level0SubLevelCompactLevelCount,
13020 Level0OverlappingSubLevelCompactLevelCount,
13021 MaxSpaceReclaimBytes,
13022 Level0MaxCompactFileNumber,
13023 EnableEmergencyPicker,
13024 TombstoneReclaimRatio,
13025 CompressionAlgorithm,
13026 MaxL0CompactLevelCount,
13027 SstAllowedTrivialMoveMinSize,
13028 SplitWeightByVnode,
13029 DisableAutoGroupScheduling,
13030 MaxOverlappingLevelSize,
13031 EmergencyLevel0SstFileCount,
13032 EmergencyLevel0SubLevelPartition,
13033 Level0StopWriteThresholdMaxSstCount,
13034 Level0StopWriteThresholdMaxSize,
13035 SstAllowedTrivialMoveMaxCount,
13036 EnableOptimizeL0IntervalSelection,
13037 VnodeAlignedLevelSizeThreshold,
13038 MaxKvCountForXor16,
13039 }
13040 impl<'de> serde::Deserialize<'de> for GeneratedField {
13041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13042 where
13043 D: serde::Deserializer<'de>,
13044 {
13045 struct GeneratedVisitor;
13046
13047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13048 type Value = GeneratedField;
13049
13050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13051 write!(formatter, "expected one of: {:?}", &FIELDS)
13052 }
13053
13054 #[allow(unused_variables)]
13055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13056 where
13057 E: serde::de::Error,
13058 {
13059 match value {
13060 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
13061 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
13062 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
13063 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
13064 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
13065 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
13066 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
13067 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
13068 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
13069 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
13070 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
13071 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
13072 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
13073 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
13074 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
13075 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
13076 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
13077 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
13078 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
13079 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
13080 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
13081 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
13082 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
13083 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
13084 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
13085 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
13086 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
13087 "vnodeAlignedLevelSizeThreshold" | "vnode_aligned_level_size_threshold" => Ok(GeneratedField::VnodeAlignedLevelSizeThreshold),
13088 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
13089 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13090 }
13091 }
13092 }
13093 deserializer.deserialize_identifier(GeneratedVisitor)
13094 }
13095 }
13096 struct GeneratedVisitor;
13097 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13098 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
13099
13100 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13101 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
13102 }
13103
13104 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
13105 where
13106 V: serde::de::MapAccess<'de>,
13107 {
13108 let mut mutable_config__ = None;
13109 while let Some(k) = map_.next_key()? {
13110 match k {
13111 GeneratedField::MaxBytesForLevelBase => {
13112 if mutable_config__.is_some() {
13113 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
13114 }
13115 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(x.0));
13116 }
13117 GeneratedField::MaxBytesForLevelMultiplier => {
13118 if mutable_config__.is_some() {
13119 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
13120 }
13121 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(x.0));
13122 }
13123 GeneratedField::MaxCompactionBytes => {
13124 if mutable_config__.is_some() {
13125 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
13126 }
13127 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(x.0));
13128 }
13129 GeneratedField::SubLevelMaxCompactionBytes => {
13130 if mutable_config__.is_some() {
13131 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
13132 }
13133 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(x.0));
13134 }
13135 GeneratedField::Level0TierCompactFileNumber => {
13136 if mutable_config__.is_some() {
13137 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
13138 }
13139 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(x.0));
13140 }
13141 GeneratedField::TargetFileSizeBase => {
13142 if mutable_config__.is_some() {
13143 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
13144 }
13145 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(x.0));
13146 }
13147 GeneratedField::CompactionFilterMask => {
13148 if mutable_config__.is_some() {
13149 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
13150 }
13151 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(x.0));
13152 }
13153 GeneratedField::MaxSubCompaction => {
13154 if mutable_config__.is_some() {
13155 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
13156 }
13157 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(x.0));
13158 }
13159 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
13160 if mutable_config__.is_some() {
13161 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
13162 }
13163 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(x.0));
13164 }
13165 GeneratedField::Level0SubLevelCompactLevelCount => {
13166 if mutable_config__.is_some() {
13167 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
13168 }
13169 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(x.0));
13170 }
13171 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
13172 if mutable_config__.is_some() {
13173 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
13174 }
13175 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(x.0));
13176 }
13177 GeneratedField::MaxSpaceReclaimBytes => {
13178 if mutable_config__.is_some() {
13179 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
13180 }
13181 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(x.0));
13182 }
13183 GeneratedField::Level0MaxCompactFileNumber => {
13184 if mutable_config__.is_some() {
13185 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
13186 }
13187 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(x.0));
13188 }
13189 GeneratedField::EnableEmergencyPicker => {
13190 if mutable_config__.is_some() {
13191 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
13192 }
13193 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
13194 }
13195 GeneratedField::TombstoneReclaimRatio => {
13196 if mutable_config__.is_some() {
13197 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
13198 }
13199 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(x.0));
13200 }
13201 GeneratedField::CompressionAlgorithm => {
13202 if mutable_config__.is_some() {
13203 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13204 }
13205 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
13206;
13207 }
13208 GeneratedField::MaxL0CompactLevelCount => {
13209 if mutable_config__.is_some() {
13210 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
13211 }
13212 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(x.0));
13213 }
13214 GeneratedField::SstAllowedTrivialMoveMinSize => {
13215 if mutable_config__.is_some() {
13216 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
13217 }
13218 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(x.0));
13219 }
13220 GeneratedField::SplitWeightByVnode => {
13221 if mutable_config__.is_some() {
13222 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
13223 }
13224 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(x.0));
13225 }
13226 GeneratedField::DisableAutoGroupScheduling => {
13227 if mutable_config__.is_some() {
13228 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
13229 }
13230 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
13231 }
13232 GeneratedField::MaxOverlappingLevelSize => {
13233 if mutable_config__.is_some() {
13234 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
13235 }
13236 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(x.0));
13237 }
13238 GeneratedField::EmergencyLevel0SstFileCount => {
13239 if mutable_config__.is_some() {
13240 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
13241 }
13242 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(x.0));
13243 }
13244 GeneratedField::EmergencyLevel0SubLevelPartition => {
13245 if mutable_config__.is_some() {
13246 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
13247 }
13248 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(x.0));
13249 }
13250 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
13251 if mutable_config__.is_some() {
13252 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
13253 }
13254 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(x.0));
13255 }
13256 GeneratedField::Level0StopWriteThresholdMaxSize => {
13257 if mutable_config__.is_some() {
13258 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
13259 }
13260 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(x.0));
13261 }
13262 GeneratedField::SstAllowedTrivialMoveMaxCount => {
13263 if mutable_config__.is_some() {
13264 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
13265 }
13266 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(x.0));
13267 }
13268 GeneratedField::EnableOptimizeL0IntervalSelection => {
13269 if mutable_config__.is_some() {
13270 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
13271 }
13272 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
13273 }
13274 GeneratedField::VnodeAlignedLevelSizeThreshold => {
13275 if mutable_config__.is_some() {
13276 return Err(serde::de::Error::duplicate_field("vnodeAlignedLevelSizeThreshold"));
13277 }
13278 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::VnodeAlignedLevelSizeThreshold(x.0));
13279 }
13280 GeneratedField::MaxKvCountForXor16 => {
13281 if mutable_config__.is_some() {
13282 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
13283 }
13284 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxKvCountForXor16(x.0));
13285 }
13286 }
13287 }
13288 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
13289 mutable_config: mutable_config__,
13290 })
13291 }
13292 }
13293 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
13294 }
13295}
13296impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
13297 #[allow(deprecated)]
13298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13299 where
13300 S: serde::Serializer,
13301 {
13302 use serde::ser::SerializeStruct;
13303 let mut len = 0;
13304 if self.status.is_some() {
13305 len += 1;
13306 }
13307 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
13308 if let Some(v) = self.status.as_ref() {
13309 struct_ser.serialize_field("status", v)?;
13310 }
13311 struct_ser.end()
13312 }
13313}
13314impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
13315 #[allow(deprecated)]
13316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13317 where
13318 D: serde::Deserializer<'de>,
13319 {
13320 const FIELDS: &[&str] = &[
13321 "status",
13322 ];
13323
13324 #[allow(clippy::enum_variant_names)]
13325 enum GeneratedField {
13326 Status,
13327 }
13328 impl<'de> serde::Deserialize<'de> for GeneratedField {
13329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13330 where
13331 D: serde::Deserializer<'de>,
13332 {
13333 struct GeneratedVisitor;
13334
13335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13336 type Value = GeneratedField;
13337
13338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13339 write!(formatter, "expected one of: {:?}", &FIELDS)
13340 }
13341
13342 #[allow(unused_variables)]
13343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13344 where
13345 E: serde::de::Error,
13346 {
13347 match value {
13348 "status" => Ok(GeneratedField::Status),
13349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13350 }
13351 }
13352 }
13353 deserializer.deserialize_identifier(GeneratedVisitor)
13354 }
13355 }
13356 struct GeneratedVisitor;
13357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13358 type Value = RiseCtlUpdateCompactionConfigResponse;
13359
13360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13361 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
13362 }
13363
13364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
13365 where
13366 V: serde::de::MapAccess<'de>,
13367 {
13368 let mut status__ = None;
13369 while let Some(k) = map_.next_key()? {
13370 match k {
13371 GeneratedField::Status => {
13372 if status__.is_some() {
13373 return Err(serde::de::Error::duplicate_field("status"));
13374 }
13375 status__ = map_.next_value()?;
13376 }
13377 }
13378 }
13379 Ok(RiseCtlUpdateCompactionConfigResponse {
13380 status: status__,
13381 })
13382 }
13383 }
13384 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
13385 }
13386}
13387impl serde::Serialize for SplitCompactionGroupRequest {
13388 #[allow(deprecated)]
13389 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13390 where
13391 S: serde::Serializer,
13392 {
13393 use serde::ser::SerializeStruct;
13394 let mut len = 0;
13395 if self.group_id != 0 {
13396 len += 1;
13397 }
13398 if !self.table_ids.is_empty() {
13399 len += 1;
13400 }
13401 if self.partition_vnode_count != 0 {
13402 len += 1;
13403 }
13404 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
13405 if self.group_id != 0 {
13406 #[allow(clippy::needless_borrow)]
13407 #[allow(clippy::needless_borrows_for_generic_args)]
13408 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
13409 }
13410 if !self.table_ids.is_empty() {
13411 struct_ser.serialize_field("tableIds", &self.table_ids)?;
13412 }
13413 if self.partition_vnode_count != 0 {
13414 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
13415 }
13416 struct_ser.end()
13417 }
13418}
13419impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
13420 #[allow(deprecated)]
13421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13422 where
13423 D: serde::Deserializer<'de>,
13424 {
13425 const FIELDS: &[&str] = &[
13426 "group_id",
13427 "groupId",
13428 "table_ids",
13429 "tableIds",
13430 "partition_vnode_count",
13431 "partitionVnodeCount",
13432 ];
13433
13434 #[allow(clippy::enum_variant_names)]
13435 enum GeneratedField {
13436 GroupId,
13437 TableIds,
13438 PartitionVnodeCount,
13439 }
13440 impl<'de> serde::Deserialize<'de> for GeneratedField {
13441 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13442 where
13443 D: serde::Deserializer<'de>,
13444 {
13445 struct GeneratedVisitor;
13446
13447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13448 type Value = GeneratedField;
13449
13450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13451 write!(formatter, "expected one of: {:?}", &FIELDS)
13452 }
13453
13454 #[allow(unused_variables)]
13455 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13456 where
13457 E: serde::de::Error,
13458 {
13459 match value {
13460 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
13461 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13462 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
13463 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13464 }
13465 }
13466 }
13467 deserializer.deserialize_identifier(GeneratedVisitor)
13468 }
13469 }
13470 struct GeneratedVisitor;
13471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13472 type Value = SplitCompactionGroupRequest;
13473
13474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13475 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
13476 }
13477
13478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
13479 where
13480 V: serde::de::MapAccess<'de>,
13481 {
13482 let mut group_id__ = None;
13483 let mut table_ids__ = None;
13484 let mut partition_vnode_count__ = None;
13485 while let Some(k) = map_.next_key()? {
13486 match k {
13487 GeneratedField::GroupId => {
13488 if group_id__.is_some() {
13489 return Err(serde::de::Error::duplicate_field("groupId"));
13490 }
13491 group_id__ =
13492 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13493 ;
13494 }
13495 GeneratedField::TableIds => {
13496 if table_ids__.is_some() {
13497 return Err(serde::de::Error::duplicate_field("tableIds"));
13498 }
13499 table_ids__ =
13500 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13501 .into_iter().map(|x| x.0).collect())
13502 ;
13503 }
13504 GeneratedField::PartitionVnodeCount => {
13505 if partition_vnode_count__.is_some() {
13506 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
13507 }
13508 partition_vnode_count__ =
13509 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13510 ;
13511 }
13512 }
13513 }
13514 Ok(SplitCompactionGroupRequest {
13515 group_id: group_id__.unwrap_or_default(),
13516 table_ids: table_ids__.unwrap_or_default(),
13517 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
13518 })
13519 }
13520 }
13521 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
13522 }
13523}
13524impl serde::Serialize for SplitCompactionGroupResponse {
13525 #[allow(deprecated)]
13526 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13527 where
13528 S: serde::Serializer,
13529 {
13530 use serde::ser::SerializeStruct;
13531 let mut len = 0;
13532 if self.new_group_id != 0 {
13533 len += 1;
13534 }
13535 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
13536 if self.new_group_id != 0 {
13537 #[allow(clippy::needless_borrow)]
13538 #[allow(clippy::needless_borrows_for_generic_args)]
13539 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
13540 }
13541 struct_ser.end()
13542 }
13543}
13544impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
13545 #[allow(deprecated)]
13546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13547 where
13548 D: serde::Deserializer<'de>,
13549 {
13550 const FIELDS: &[&str] = &[
13551 "new_group_id",
13552 "newGroupId",
13553 ];
13554
13555 #[allow(clippy::enum_variant_names)]
13556 enum GeneratedField {
13557 NewGroupId,
13558 }
13559 impl<'de> serde::Deserialize<'de> for GeneratedField {
13560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13561 where
13562 D: serde::Deserializer<'de>,
13563 {
13564 struct GeneratedVisitor;
13565
13566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13567 type Value = GeneratedField;
13568
13569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13570 write!(formatter, "expected one of: {:?}", &FIELDS)
13571 }
13572
13573 #[allow(unused_variables)]
13574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13575 where
13576 E: serde::de::Error,
13577 {
13578 match value {
13579 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
13580 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13581 }
13582 }
13583 }
13584 deserializer.deserialize_identifier(GeneratedVisitor)
13585 }
13586 }
13587 struct GeneratedVisitor;
13588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13589 type Value = SplitCompactionGroupResponse;
13590
13591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13592 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
13593 }
13594
13595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
13596 where
13597 V: serde::de::MapAccess<'de>,
13598 {
13599 let mut new_group_id__ = None;
13600 while let Some(k) = map_.next_key()? {
13601 match k {
13602 GeneratedField::NewGroupId => {
13603 if new_group_id__.is_some() {
13604 return Err(serde::de::Error::duplicate_field("newGroupId"));
13605 }
13606 new_group_id__ =
13607 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13608 ;
13609 }
13610 }
13611 }
13612 Ok(SplitCompactionGroupResponse {
13613 new_group_id: new_group_id__.unwrap_or_default(),
13614 })
13615 }
13616 }
13617 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
13618 }
13619}
13620impl serde::Serialize for SstableInfo {
13621 #[allow(deprecated)]
13622 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13623 where
13624 S: serde::Serializer,
13625 {
13626 use serde::ser::SerializeStruct;
13627 let mut len = 0;
13628 if self.object_id != 0 {
13629 len += 1;
13630 }
13631 if self.sst_id != 0 {
13632 len += 1;
13633 }
13634 if self.key_range.is_some() {
13635 len += 1;
13636 }
13637 if self.file_size != 0 {
13638 len += 1;
13639 }
13640 if !self.table_ids.is_empty() {
13641 len += 1;
13642 }
13643 if self.meta_offset != 0 {
13644 len += 1;
13645 }
13646 if self.stale_key_count != 0 {
13647 len += 1;
13648 }
13649 if self.total_key_count != 0 {
13650 len += 1;
13651 }
13652 if self.min_epoch != 0 {
13653 len += 1;
13654 }
13655 if self.max_epoch != 0 {
13656 len += 1;
13657 }
13658 if self.uncompressed_file_size != 0 {
13659 len += 1;
13660 }
13661 if self.range_tombstone_count != 0 {
13662 len += 1;
13663 }
13664 if self.bloom_filter_kind != 0 {
13665 len += 1;
13666 }
13667 if self.sst_size != 0 {
13668 len += 1;
13669 }
13670 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
13671 if self.object_id != 0 {
13672 #[allow(clippy::needless_borrow)]
13673 #[allow(clippy::needless_borrows_for_generic_args)]
13674 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
13675 }
13676 if self.sst_id != 0 {
13677 #[allow(clippy::needless_borrow)]
13678 #[allow(clippy::needless_borrows_for_generic_args)]
13679 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
13680 }
13681 if let Some(v) = self.key_range.as_ref() {
13682 struct_ser.serialize_field("keyRange", v)?;
13683 }
13684 if self.file_size != 0 {
13685 #[allow(clippy::needless_borrow)]
13686 #[allow(clippy::needless_borrows_for_generic_args)]
13687 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
13688 }
13689 if !self.table_ids.is_empty() {
13690 struct_ser.serialize_field("tableIds", &self.table_ids)?;
13691 }
13692 if self.meta_offset != 0 {
13693 #[allow(clippy::needless_borrow)]
13694 #[allow(clippy::needless_borrows_for_generic_args)]
13695 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
13696 }
13697 if self.stale_key_count != 0 {
13698 #[allow(clippy::needless_borrow)]
13699 #[allow(clippy::needless_borrows_for_generic_args)]
13700 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
13701 }
13702 if self.total_key_count != 0 {
13703 #[allow(clippy::needless_borrow)]
13704 #[allow(clippy::needless_borrows_for_generic_args)]
13705 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
13706 }
13707 if self.min_epoch != 0 {
13708 #[allow(clippy::needless_borrow)]
13709 #[allow(clippy::needless_borrows_for_generic_args)]
13710 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
13711 }
13712 if self.max_epoch != 0 {
13713 #[allow(clippy::needless_borrow)]
13714 #[allow(clippy::needless_borrows_for_generic_args)]
13715 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
13716 }
13717 if self.uncompressed_file_size != 0 {
13718 #[allow(clippy::needless_borrow)]
13719 #[allow(clippy::needless_borrows_for_generic_args)]
13720 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
13721 }
13722 if self.range_tombstone_count != 0 {
13723 #[allow(clippy::needless_borrow)]
13724 #[allow(clippy::needless_borrows_for_generic_args)]
13725 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
13726 }
13727 if self.bloom_filter_kind != 0 {
13728 let v = BloomFilterType::try_from(self.bloom_filter_kind)
13729 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
13730 struct_ser.serialize_field("bloomFilterKind", &v)?;
13731 }
13732 if self.sst_size != 0 {
13733 #[allow(clippy::needless_borrow)]
13734 #[allow(clippy::needless_borrows_for_generic_args)]
13735 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
13736 }
13737 struct_ser.end()
13738 }
13739}
13740impl<'de> serde::Deserialize<'de> for SstableInfo {
13741 #[allow(deprecated)]
13742 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13743 where
13744 D: serde::Deserializer<'de>,
13745 {
13746 const FIELDS: &[&str] = &[
13747 "object_id",
13748 "objectId",
13749 "sst_id",
13750 "sstId",
13751 "key_range",
13752 "keyRange",
13753 "file_size",
13754 "fileSize",
13755 "table_ids",
13756 "tableIds",
13757 "meta_offset",
13758 "metaOffset",
13759 "stale_key_count",
13760 "staleKeyCount",
13761 "total_key_count",
13762 "totalKeyCount",
13763 "min_epoch",
13764 "minEpoch",
13765 "max_epoch",
13766 "maxEpoch",
13767 "uncompressed_file_size",
13768 "uncompressedFileSize",
13769 "range_tombstone_count",
13770 "rangeTombstoneCount",
13771 "bloom_filter_kind",
13772 "bloomFilterKind",
13773 "sst_size",
13774 "sstSize",
13775 ];
13776
13777 #[allow(clippy::enum_variant_names)]
13778 enum GeneratedField {
13779 ObjectId,
13780 SstId,
13781 KeyRange,
13782 FileSize,
13783 TableIds,
13784 MetaOffset,
13785 StaleKeyCount,
13786 TotalKeyCount,
13787 MinEpoch,
13788 MaxEpoch,
13789 UncompressedFileSize,
13790 RangeTombstoneCount,
13791 BloomFilterKind,
13792 SstSize,
13793 }
13794 impl<'de> serde::Deserialize<'de> for GeneratedField {
13795 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13796 where
13797 D: serde::Deserializer<'de>,
13798 {
13799 struct GeneratedVisitor;
13800
13801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13802 type Value = GeneratedField;
13803
13804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13805 write!(formatter, "expected one of: {:?}", &FIELDS)
13806 }
13807
13808 #[allow(unused_variables)]
13809 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13810 where
13811 E: serde::de::Error,
13812 {
13813 match value {
13814 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
13815 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
13816 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
13817 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
13818 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13819 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
13820 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
13821 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
13822 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
13823 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
13824 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
13825 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
13826 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
13827 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
13828 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13829 }
13830 }
13831 }
13832 deserializer.deserialize_identifier(GeneratedVisitor)
13833 }
13834 }
13835 struct GeneratedVisitor;
13836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13837 type Value = SstableInfo;
13838
13839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13840 formatter.write_str("struct hummock.SstableInfo")
13841 }
13842
13843 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
13844 where
13845 V: serde::de::MapAccess<'de>,
13846 {
13847 let mut object_id__ = None;
13848 let mut sst_id__ = None;
13849 let mut key_range__ = None;
13850 let mut file_size__ = None;
13851 let mut table_ids__ = None;
13852 let mut meta_offset__ = None;
13853 let mut stale_key_count__ = None;
13854 let mut total_key_count__ = None;
13855 let mut min_epoch__ = None;
13856 let mut max_epoch__ = None;
13857 let mut uncompressed_file_size__ = None;
13858 let mut range_tombstone_count__ = None;
13859 let mut bloom_filter_kind__ = None;
13860 let mut sst_size__ = None;
13861 while let Some(k) = map_.next_key()? {
13862 match k {
13863 GeneratedField::ObjectId => {
13864 if object_id__.is_some() {
13865 return Err(serde::de::Error::duplicate_field("objectId"));
13866 }
13867 object_id__ =
13868 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13869 ;
13870 }
13871 GeneratedField::SstId => {
13872 if sst_id__.is_some() {
13873 return Err(serde::de::Error::duplicate_field("sstId"));
13874 }
13875 sst_id__ =
13876 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13877 ;
13878 }
13879 GeneratedField::KeyRange => {
13880 if key_range__.is_some() {
13881 return Err(serde::de::Error::duplicate_field("keyRange"));
13882 }
13883 key_range__ = map_.next_value()?;
13884 }
13885 GeneratedField::FileSize => {
13886 if file_size__.is_some() {
13887 return Err(serde::de::Error::duplicate_field("fileSize"));
13888 }
13889 file_size__ =
13890 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13891 ;
13892 }
13893 GeneratedField::TableIds => {
13894 if table_ids__.is_some() {
13895 return Err(serde::de::Error::duplicate_field("tableIds"));
13896 }
13897 table_ids__ =
13898 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13899 .into_iter().map(|x| x.0).collect())
13900 ;
13901 }
13902 GeneratedField::MetaOffset => {
13903 if meta_offset__.is_some() {
13904 return Err(serde::de::Error::duplicate_field("metaOffset"));
13905 }
13906 meta_offset__ =
13907 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13908 ;
13909 }
13910 GeneratedField::StaleKeyCount => {
13911 if stale_key_count__.is_some() {
13912 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
13913 }
13914 stale_key_count__ =
13915 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13916 ;
13917 }
13918 GeneratedField::TotalKeyCount => {
13919 if total_key_count__.is_some() {
13920 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
13921 }
13922 total_key_count__ =
13923 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13924 ;
13925 }
13926 GeneratedField::MinEpoch => {
13927 if min_epoch__.is_some() {
13928 return Err(serde::de::Error::duplicate_field("minEpoch"));
13929 }
13930 min_epoch__ =
13931 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13932 ;
13933 }
13934 GeneratedField::MaxEpoch => {
13935 if max_epoch__.is_some() {
13936 return Err(serde::de::Error::duplicate_field("maxEpoch"));
13937 }
13938 max_epoch__ =
13939 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13940 ;
13941 }
13942 GeneratedField::UncompressedFileSize => {
13943 if uncompressed_file_size__.is_some() {
13944 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
13945 }
13946 uncompressed_file_size__ =
13947 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13948 ;
13949 }
13950 GeneratedField::RangeTombstoneCount => {
13951 if range_tombstone_count__.is_some() {
13952 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
13953 }
13954 range_tombstone_count__ =
13955 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13956 ;
13957 }
13958 GeneratedField::BloomFilterKind => {
13959 if bloom_filter_kind__.is_some() {
13960 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
13961 }
13962 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
13963 }
13964 GeneratedField::SstSize => {
13965 if sst_size__.is_some() {
13966 return Err(serde::de::Error::duplicate_field("sstSize"));
13967 }
13968 sst_size__ =
13969 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13970 ;
13971 }
13972 }
13973 }
13974 Ok(SstableInfo {
13975 object_id: object_id__.unwrap_or_default(),
13976 sst_id: sst_id__.unwrap_or_default(),
13977 key_range: key_range__,
13978 file_size: file_size__.unwrap_or_default(),
13979 table_ids: table_ids__.unwrap_or_default(),
13980 meta_offset: meta_offset__.unwrap_or_default(),
13981 stale_key_count: stale_key_count__.unwrap_or_default(),
13982 total_key_count: total_key_count__.unwrap_or_default(),
13983 min_epoch: min_epoch__.unwrap_or_default(),
13984 max_epoch: max_epoch__.unwrap_or_default(),
13985 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
13986 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
13987 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
13988 sst_size: sst_size__.unwrap_or_default(),
13989 })
13990 }
13991 }
13992 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
13993 }
13994}
13995impl serde::Serialize for StateTableInfo {
13996 #[allow(deprecated)]
13997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13998 where
13999 S: serde::Serializer,
14000 {
14001 use serde::ser::SerializeStruct;
14002 let mut len = 0;
14003 if self.committed_epoch != 0 {
14004 len += 1;
14005 }
14006 if self.compaction_group_id != 0 {
14007 len += 1;
14008 }
14009 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
14010 if self.committed_epoch != 0 {
14011 #[allow(clippy::needless_borrow)]
14012 #[allow(clippy::needless_borrows_for_generic_args)]
14013 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
14014 }
14015 if self.compaction_group_id != 0 {
14016 #[allow(clippy::needless_borrow)]
14017 #[allow(clippy::needless_borrows_for_generic_args)]
14018 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
14019 }
14020 struct_ser.end()
14021 }
14022}
14023impl<'de> serde::Deserialize<'de> for StateTableInfo {
14024 #[allow(deprecated)]
14025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14026 where
14027 D: serde::Deserializer<'de>,
14028 {
14029 const FIELDS: &[&str] = &[
14030 "committed_epoch",
14031 "committedEpoch",
14032 "compaction_group_id",
14033 "compactionGroupId",
14034 ];
14035
14036 #[allow(clippy::enum_variant_names)]
14037 enum GeneratedField {
14038 CommittedEpoch,
14039 CompactionGroupId,
14040 }
14041 impl<'de> serde::Deserialize<'de> for GeneratedField {
14042 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14043 where
14044 D: serde::Deserializer<'de>,
14045 {
14046 struct GeneratedVisitor;
14047
14048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14049 type Value = GeneratedField;
14050
14051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14052 write!(formatter, "expected one of: {:?}", &FIELDS)
14053 }
14054
14055 #[allow(unused_variables)]
14056 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14057 where
14058 E: serde::de::Error,
14059 {
14060 match value {
14061 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
14062 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
14063 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14064 }
14065 }
14066 }
14067 deserializer.deserialize_identifier(GeneratedVisitor)
14068 }
14069 }
14070 struct GeneratedVisitor;
14071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14072 type Value = StateTableInfo;
14073
14074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14075 formatter.write_str("struct hummock.StateTableInfo")
14076 }
14077
14078 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
14079 where
14080 V: serde::de::MapAccess<'de>,
14081 {
14082 let mut committed_epoch__ = None;
14083 let mut compaction_group_id__ = None;
14084 while let Some(k) = map_.next_key()? {
14085 match k {
14086 GeneratedField::CommittedEpoch => {
14087 if committed_epoch__.is_some() {
14088 return Err(serde::de::Error::duplicate_field("committedEpoch"));
14089 }
14090 committed_epoch__ =
14091 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14092 ;
14093 }
14094 GeneratedField::CompactionGroupId => {
14095 if compaction_group_id__.is_some() {
14096 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14097 }
14098 compaction_group_id__ =
14099 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14100 ;
14101 }
14102 }
14103 }
14104 Ok(StateTableInfo {
14105 committed_epoch: committed_epoch__.unwrap_or_default(),
14106 compaction_group_id: compaction_group_id__.unwrap_or_default(),
14107 })
14108 }
14109 }
14110 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
14111 }
14112}
14113impl serde::Serialize for StateTableInfoDelta {
14114 #[allow(deprecated)]
14115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14116 where
14117 S: serde::Serializer,
14118 {
14119 use serde::ser::SerializeStruct;
14120 let mut len = 0;
14121 if self.committed_epoch != 0 {
14122 len += 1;
14123 }
14124 if self.compaction_group_id != 0 {
14125 len += 1;
14126 }
14127 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
14128 if self.committed_epoch != 0 {
14129 #[allow(clippy::needless_borrow)]
14130 #[allow(clippy::needless_borrows_for_generic_args)]
14131 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
14132 }
14133 if self.compaction_group_id != 0 {
14134 #[allow(clippy::needless_borrow)]
14135 #[allow(clippy::needless_borrows_for_generic_args)]
14136 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
14137 }
14138 struct_ser.end()
14139 }
14140}
14141impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
14142 #[allow(deprecated)]
14143 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14144 where
14145 D: serde::Deserializer<'de>,
14146 {
14147 const FIELDS: &[&str] = &[
14148 "committed_epoch",
14149 "committedEpoch",
14150 "compaction_group_id",
14151 "compactionGroupId",
14152 ];
14153
14154 #[allow(clippy::enum_variant_names)]
14155 enum GeneratedField {
14156 CommittedEpoch,
14157 CompactionGroupId,
14158 }
14159 impl<'de> serde::Deserialize<'de> for GeneratedField {
14160 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14161 where
14162 D: serde::Deserializer<'de>,
14163 {
14164 struct GeneratedVisitor;
14165
14166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14167 type Value = GeneratedField;
14168
14169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14170 write!(formatter, "expected one of: {:?}", &FIELDS)
14171 }
14172
14173 #[allow(unused_variables)]
14174 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14175 where
14176 E: serde::de::Error,
14177 {
14178 match value {
14179 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
14180 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
14181 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14182 }
14183 }
14184 }
14185 deserializer.deserialize_identifier(GeneratedVisitor)
14186 }
14187 }
14188 struct GeneratedVisitor;
14189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14190 type Value = StateTableInfoDelta;
14191
14192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14193 formatter.write_str("struct hummock.StateTableInfoDelta")
14194 }
14195
14196 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
14197 where
14198 V: serde::de::MapAccess<'de>,
14199 {
14200 let mut committed_epoch__ = None;
14201 let mut compaction_group_id__ = None;
14202 while let Some(k) = map_.next_key()? {
14203 match k {
14204 GeneratedField::CommittedEpoch => {
14205 if committed_epoch__.is_some() {
14206 return Err(serde::de::Error::duplicate_field("committedEpoch"));
14207 }
14208 committed_epoch__ =
14209 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14210 ;
14211 }
14212 GeneratedField::CompactionGroupId => {
14213 if compaction_group_id__.is_some() {
14214 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14215 }
14216 compaction_group_id__ =
14217 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14218 ;
14219 }
14220 }
14221 }
14222 Ok(StateTableInfoDelta {
14223 committed_epoch: committed_epoch__.unwrap_or_default(),
14224 compaction_group_id: compaction_group_id__.unwrap_or_default(),
14225 })
14226 }
14227 }
14228 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
14229 }
14230}
14231impl serde::Serialize for SubscribeCompactionEventRequest {
14232 #[allow(deprecated)]
14233 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14234 where
14235 S: serde::Serializer,
14236 {
14237 use serde::ser::SerializeStruct;
14238 let mut len = 0;
14239 if self.create_at != 0 {
14240 len += 1;
14241 }
14242 if self.event.is_some() {
14243 len += 1;
14244 }
14245 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
14246 if self.create_at != 0 {
14247 #[allow(clippy::needless_borrow)]
14248 #[allow(clippy::needless_borrows_for_generic_args)]
14249 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14250 }
14251 if let Some(v) = self.event.as_ref() {
14252 match v {
14253 subscribe_compaction_event_request::Event::Register(v) => {
14254 struct_ser.serialize_field("register", v)?;
14255 }
14256 subscribe_compaction_event_request::Event::PullTask(v) => {
14257 struct_ser.serialize_field("pullTask", v)?;
14258 }
14259 subscribe_compaction_event_request::Event::ReportTask(v) => {
14260 struct_ser.serialize_field("reportTask", v)?;
14261 }
14262 subscribe_compaction_event_request::Event::HeartBeat(v) => {
14263 struct_ser.serialize_field("heartBeat", v)?;
14264 }
14265 }
14266 }
14267 struct_ser.end()
14268 }
14269}
14270impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
14271 #[allow(deprecated)]
14272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14273 where
14274 D: serde::Deserializer<'de>,
14275 {
14276 const FIELDS: &[&str] = &[
14277 "create_at",
14278 "createAt",
14279 "register",
14280 "pull_task",
14281 "pullTask",
14282 "report_task",
14283 "reportTask",
14284 "heart_beat",
14285 "heartBeat",
14286 ];
14287
14288 #[allow(clippy::enum_variant_names)]
14289 enum GeneratedField {
14290 CreateAt,
14291 Register,
14292 PullTask,
14293 ReportTask,
14294 HeartBeat,
14295 }
14296 impl<'de> serde::Deserialize<'de> for GeneratedField {
14297 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14298 where
14299 D: serde::Deserializer<'de>,
14300 {
14301 struct GeneratedVisitor;
14302
14303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14304 type Value = GeneratedField;
14305
14306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14307 write!(formatter, "expected one of: {:?}", &FIELDS)
14308 }
14309
14310 #[allow(unused_variables)]
14311 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14312 where
14313 E: serde::de::Error,
14314 {
14315 match value {
14316 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14317 "register" => Ok(GeneratedField::Register),
14318 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
14319 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
14320 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
14321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14322 }
14323 }
14324 }
14325 deserializer.deserialize_identifier(GeneratedVisitor)
14326 }
14327 }
14328 struct GeneratedVisitor;
14329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14330 type Value = SubscribeCompactionEventRequest;
14331
14332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14333 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
14334 }
14335
14336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
14337 where
14338 V: serde::de::MapAccess<'de>,
14339 {
14340 let mut create_at__ = None;
14341 let mut event__ = None;
14342 while let Some(k) = map_.next_key()? {
14343 match k {
14344 GeneratedField::CreateAt => {
14345 if create_at__.is_some() {
14346 return Err(serde::de::Error::duplicate_field("createAt"));
14347 }
14348 create_at__ =
14349 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14350 ;
14351 }
14352 GeneratedField::Register => {
14353 if event__.is_some() {
14354 return Err(serde::de::Error::duplicate_field("register"));
14355 }
14356 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
14357;
14358 }
14359 GeneratedField::PullTask => {
14360 if event__.is_some() {
14361 return Err(serde::de::Error::duplicate_field("pullTask"));
14362 }
14363 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
14364;
14365 }
14366 GeneratedField::ReportTask => {
14367 if event__.is_some() {
14368 return Err(serde::de::Error::duplicate_field("reportTask"));
14369 }
14370 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
14371;
14372 }
14373 GeneratedField::HeartBeat => {
14374 if event__.is_some() {
14375 return Err(serde::de::Error::duplicate_field("heartBeat"));
14376 }
14377 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
14378;
14379 }
14380 }
14381 }
14382 Ok(SubscribeCompactionEventRequest {
14383 create_at: create_at__.unwrap_or_default(),
14384 event: event__,
14385 })
14386 }
14387 }
14388 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
14389 }
14390}
14391impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
14392 #[allow(deprecated)]
14393 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14394 where
14395 S: serde::Serializer,
14396 {
14397 use serde::ser::SerializeStruct;
14398 let mut len = 0;
14399 if !self.progress.is_empty() {
14400 len += 1;
14401 }
14402 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
14403 if !self.progress.is_empty() {
14404 struct_ser.serialize_field("progress", &self.progress)?;
14405 }
14406 struct_ser.end()
14407 }
14408}
14409impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
14410 #[allow(deprecated)]
14411 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14412 where
14413 D: serde::Deserializer<'de>,
14414 {
14415 const FIELDS: &[&str] = &[
14416 "progress",
14417 ];
14418
14419 #[allow(clippy::enum_variant_names)]
14420 enum GeneratedField {
14421 Progress,
14422 }
14423 impl<'de> serde::Deserialize<'de> for GeneratedField {
14424 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14425 where
14426 D: serde::Deserializer<'de>,
14427 {
14428 struct GeneratedVisitor;
14429
14430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14431 type Value = GeneratedField;
14432
14433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14434 write!(formatter, "expected one of: {:?}", &FIELDS)
14435 }
14436
14437 #[allow(unused_variables)]
14438 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14439 where
14440 E: serde::de::Error,
14441 {
14442 match value {
14443 "progress" => Ok(GeneratedField::Progress),
14444 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14445 }
14446 }
14447 }
14448 deserializer.deserialize_identifier(GeneratedVisitor)
14449 }
14450 }
14451 struct GeneratedVisitor;
14452 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14453 type Value = subscribe_compaction_event_request::HeartBeat;
14454
14455 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14456 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
14457 }
14458
14459 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
14460 where
14461 V: serde::de::MapAccess<'de>,
14462 {
14463 let mut progress__ = None;
14464 while let Some(k) = map_.next_key()? {
14465 match k {
14466 GeneratedField::Progress => {
14467 if progress__.is_some() {
14468 return Err(serde::de::Error::duplicate_field("progress"));
14469 }
14470 progress__ = Some(map_.next_value()?);
14471 }
14472 }
14473 }
14474 Ok(subscribe_compaction_event_request::HeartBeat {
14475 progress: progress__.unwrap_or_default(),
14476 })
14477 }
14478 }
14479 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
14480 }
14481}
14482impl serde::Serialize for subscribe_compaction_event_request::PullTask {
14483 #[allow(deprecated)]
14484 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14485 where
14486 S: serde::Serializer,
14487 {
14488 use serde::ser::SerializeStruct;
14489 let mut len = 0;
14490 if self.pull_task_count != 0 {
14491 len += 1;
14492 }
14493 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
14494 if self.pull_task_count != 0 {
14495 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
14496 }
14497 struct_ser.end()
14498 }
14499}
14500impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
14501 #[allow(deprecated)]
14502 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14503 where
14504 D: serde::Deserializer<'de>,
14505 {
14506 const FIELDS: &[&str] = &[
14507 "pull_task_count",
14508 "pullTaskCount",
14509 ];
14510
14511 #[allow(clippy::enum_variant_names)]
14512 enum GeneratedField {
14513 PullTaskCount,
14514 }
14515 impl<'de> serde::Deserialize<'de> for GeneratedField {
14516 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14517 where
14518 D: serde::Deserializer<'de>,
14519 {
14520 struct GeneratedVisitor;
14521
14522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14523 type Value = GeneratedField;
14524
14525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14526 write!(formatter, "expected one of: {:?}", &FIELDS)
14527 }
14528
14529 #[allow(unused_variables)]
14530 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14531 where
14532 E: serde::de::Error,
14533 {
14534 match value {
14535 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
14536 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14537 }
14538 }
14539 }
14540 deserializer.deserialize_identifier(GeneratedVisitor)
14541 }
14542 }
14543 struct GeneratedVisitor;
14544 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14545 type Value = subscribe_compaction_event_request::PullTask;
14546
14547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14548 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
14549 }
14550
14551 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
14552 where
14553 V: serde::de::MapAccess<'de>,
14554 {
14555 let mut pull_task_count__ = None;
14556 while let Some(k) = map_.next_key()? {
14557 match k {
14558 GeneratedField::PullTaskCount => {
14559 if pull_task_count__.is_some() {
14560 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
14561 }
14562 pull_task_count__ =
14563 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14564 ;
14565 }
14566 }
14567 }
14568 Ok(subscribe_compaction_event_request::PullTask {
14569 pull_task_count: pull_task_count__.unwrap_or_default(),
14570 })
14571 }
14572 }
14573 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
14574 }
14575}
14576impl serde::Serialize for subscribe_compaction_event_request::Register {
14577 #[allow(deprecated)]
14578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14579 where
14580 S: serde::Serializer,
14581 {
14582 use serde::ser::SerializeStruct;
14583 let mut len = 0;
14584 if self.context_id != 0 {
14585 len += 1;
14586 }
14587 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
14588 if self.context_id != 0 {
14589 struct_ser.serialize_field("contextId", &self.context_id)?;
14590 }
14591 struct_ser.end()
14592 }
14593}
14594impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
14595 #[allow(deprecated)]
14596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14597 where
14598 D: serde::Deserializer<'de>,
14599 {
14600 const FIELDS: &[&str] = &[
14601 "context_id",
14602 "contextId",
14603 ];
14604
14605 #[allow(clippy::enum_variant_names)]
14606 enum GeneratedField {
14607 ContextId,
14608 }
14609 impl<'de> serde::Deserialize<'de> for GeneratedField {
14610 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14611 where
14612 D: serde::Deserializer<'de>,
14613 {
14614 struct GeneratedVisitor;
14615
14616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14617 type Value = GeneratedField;
14618
14619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14620 write!(formatter, "expected one of: {:?}", &FIELDS)
14621 }
14622
14623 #[allow(unused_variables)]
14624 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14625 where
14626 E: serde::de::Error,
14627 {
14628 match value {
14629 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
14630 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14631 }
14632 }
14633 }
14634 deserializer.deserialize_identifier(GeneratedVisitor)
14635 }
14636 }
14637 struct GeneratedVisitor;
14638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14639 type Value = subscribe_compaction_event_request::Register;
14640
14641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14642 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
14643 }
14644
14645 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
14646 where
14647 V: serde::de::MapAccess<'de>,
14648 {
14649 let mut context_id__ = None;
14650 while let Some(k) = map_.next_key()? {
14651 match k {
14652 GeneratedField::ContextId => {
14653 if context_id__.is_some() {
14654 return Err(serde::de::Error::duplicate_field("contextId"));
14655 }
14656 context_id__ =
14657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14658 ;
14659 }
14660 }
14661 }
14662 Ok(subscribe_compaction_event_request::Register {
14663 context_id: context_id__.unwrap_or_default(),
14664 })
14665 }
14666 }
14667 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
14668 }
14669}
14670impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
14671 #[allow(deprecated)]
14672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14673 where
14674 S: serde::Serializer,
14675 {
14676 use serde::ser::SerializeStruct;
14677 let mut len = 0;
14678 if !self.table_stats_change.is_empty() {
14679 len += 1;
14680 }
14681 if self.task_id != 0 {
14682 len += 1;
14683 }
14684 if self.task_status != 0 {
14685 len += 1;
14686 }
14687 if !self.sorted_output_ssts.is_empty() {
14688 len += 1;
14689 }
14690 if !self.object_timestamps.is_empty() {
14691 len += 1;
14692 }
14693 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
14694 if !self.table_stats_change.is_empty() {
14695 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
14696 }
14697 if self.task_id != 0 {
14698 #[allow(clippy::needless_borrow)]
14699 #[allow(clippy::needless_borrows_for_generic_args)]
14700 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
14701 }
14702 if self.task_status != 0 {
14703 let v = compact_task::TaskStatus::try_from(self.task_status)
14704 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
14705 struct_ser.serialize_field("taskStatus", &v)?;
14706 }
14707 if !self.sorted_output_ssts.is_empty() {
14708 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
14709 }
14710 if !self.object_timestamps.is_empty() {
14711 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
14712 .map(|(k, v)| (k, v.to_string())).collect();
14713 struct_ser.serialize_field("objectTimestamps", &v)?;
14714 }
14715 struct_ser.end()
14716 }
14717}
14718impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
14719 #[allow(deprecated)]
14720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14721 where
14722 D: serde::Deserializer<'de>,
14723 {
14724 const FIELDS: &[&str] = &[
14725 "table_stats_change",
14726 "tableStatsChange",
14727 "task_id",
14728 "taskId",
14729 "task_status",
14730 "taskStatus",
14731 "sorted_output_ssts",
14732 "sortedOutputSsts",
14733 "object_timestamps",
14734 "objectTimestamps",
14735 ];
14736
14737 #[allow(clippy::enum_variant_names)]
14738 enum GeneratedField {
14739 TableStatsChange,
14740 TaskId,
14741 TaskStatus,
14742 SortedOutputSsts,
14743 ObjectTimestamps,
14744 }
14745 impl<'de> serde::Deserialize<'de> for GeneratedField {
14746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14747 where
14748 D: serde::Deserializer<'de>,
14749 {
14750 struct GeneratedVisitor;
14751
14752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14753 type Value = GeneratedField;
14754
14755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14756 write!(formatter, "expected one of: {:?}", &FIELDS)
14757 }
14758
14759 #[allow(unused_variables)]
14760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14761 where
14762 E: serde::de::Error,
14763 {
14764 match value {
14765 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
14766 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
14767 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
14768 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
14769 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
14770 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14771 }
14772 }
14773 }
14774 deserializer.deserialize_identifier(GeneratedVisitor)
14775 }
14776 }
14777 struct GeneratedVisitor;
14778 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14779 type Value = subscribe_compaction_event_request::ReportTask;
14780
14781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14782 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
14783 }
14784
14785 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
14786 where
14787 V: serde::de::MapAccess<'de>,
14788 {
14789 let mut table_stats_change__ = None;
14790 let mut task_id__ = None;
14791 let mut task_status__ = None;
14792 let mut sorted_output_ssts__ = None;
14793 let mut object_timestamps__ = None;
14794 while let Some(k) = map_.next_key()? {
14795 match k {
14796 GeneratedField::TableStatsChange => {
14797 if table_stats_change__.is_some() {
14798 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
14799 }
14800 table_stats_change__ = Some(
14801 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14802 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14803 );
14804 }
14805 GeneratedField::TaskId => {
14806 if task_id__.is_some() {
14807 return Err(serde::de::Error::duplicate_field("taskId"));
14808 }
14809 task_id__ =
14810 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14811 ;
14812 }
14813 GeneratedField::TaskStatus => {
14814 if task_status__.is_some() {
14815 return Err(serde::de::Error::duplicate_field("taskStatus"));
14816 }
14817 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
14818 }
14819 GeneratedField::SortedOutputSsts => {
14820 if sorted_output_ssts__.is_some() {
14821 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
14822 }
14823 sorted_output_ssts__ = Some(map_.next_value()?);
14824 }
14825 GeneratedField::ObjectTimestamps => {
14826 if object_timestamps__.is_some() {
14827 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
14828 }
14829 object_timestamps__ = Some(
14830 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14831 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
14832 );
14833 }
14834 }
14835 }
14836 Ok(subscribe_compaction_event_request::ReportTask {
14837 table_stats_change: table_stats_change__.unwrap_or_default(),
14838 task_id: task_id__.unwrap_or_default(),
14839 task_status: task_status__.unwrap_or_default(),
14840 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
14841 object_timestamps: object_timestamps__.unwrap_or_default(),
14842 })
14843 }
14844 }
14845 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
14846 }
14847}
14848impl serde::Serialize for SubscribeCompactionEventResponse {
14849 #[allow(deprecated)]
14850 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14851 where
14852 S: serde::Serializer,
14853 {
14854 use serde::ser::SerializeStruct;
14855 let mut len = 0;
14856 if self.create_at != 0 {
14857 len += 1;
14858 }
14859 if self.event.is_some() {
14860 len += 1;
14861 }
14862 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
14863 if self.create_at != 0 {
14864 #[allow(clippy::needless_borrow)]
14865 #[allow(clippy::needless_borrows_for_generic_args)]
14866 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14867 }
14868 if let Some(v) = self.event.as_ref() {
14869 match v {
14870 subscribe_compaction_event_response::Event::CompactTask(v) => {
14871 struct_ser.serialize_field("compactTask", v)?;
14872 }
14873 subscribe_compaction_event_response::Event::VacuumTask(v) => {
14874 struct_ser.serialize_field("vacuumTask", v)?;
14875 }
14876 subscribe_compaction_event_response::Event::FullScanTask(v) => {
14877 struct_ser.serialize_field("fullScanTask", v)?;
14878 }
14879 subscribe_compaction_event_response::Event::ValidationTask(v) => {
14880 struct_ser.serialize_field("validationTask", v)?;
14881 }
14882 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
14883 struct_ser.serialize_field("cancelCompactTask", v)?;
14884 }
14885 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
14886 struct_ser.serialize_field("pullTaskAck", v)?;
14887 }
14888 }
14889 }
14890 struct_ser.end()
14891 }
14892}
14893impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
14894 #[allow(deprecated)]
14895 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14896 where
14897 D: serde::Deserializer<'de>,
14898 {
14899 const FIELDS: &[&str] = &[
14900 "create_at",
14901 "createAt",
14902 "compact_task",
14903 "compactTask",
14904 "vacuum_task",
14905 "vacuumTask",
14906 "full_scan_task",
14907 "fullScanTask",
14908 "validation_task",
14909 "validationTask",
14910 "cancel_compact_task",
14911 "cancelCompactTask",
14912 "pull_task_ack",
14913 "pullTaskAck",
14914 ];
14915
14916 #[allow(clippy::enum_variant_names)]
14917 enum GeneratedField {
14918 CreateAt,
14919 CompactTask,
14920 VacuumTask,
14921 FullScanTask,
14922 ValidationTask,
14923 CancelCompactTask,
14924 PullTaskAck,
14925 }
14926 impl<'de> serde::Deserialize<'de> for GeneratedField {
14927 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14928 where
14929 D: serde::Deserializer<'de>,
14930 {
14931 struct GeneratedVisitor;
14932
14933 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14934 type Value = GeneratedField;
14935
14936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14937 write!(formatter, "expected one of: {:?}", &FIELDS)
14938 }
14939
14940 #[allow(unused_variables)]
14941 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14942 where
14943 E: serde::de::Error,
14944 {
14945 match value {
14946 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14947 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
14948 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
14949 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
14950 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
14951 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
14952 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
14953 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14954 }
14955 }
14956 }
14957 deserializer.deserialize_identifier(GeneratedVisitor)
14958 }
14959 }
14960 struct GeneratedVisitor;
14961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14962 type Value = SubscribeCompactionEventResponse;
14963
14964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14965 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
14966 }
14967
14968 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
14969 where
14970 V: serde::de::MapAccess<'de>,
14971 {
14972 let mut create_at__ = None;
14973 let mut event__ = None;
14974 while let Some(k) = map_.next_key()? {
14975 match k {
14976 GeneratedField::CreateAt => {
14977 if create_at__.is_some() {
14978 return Err(serde::de::Error::duplicate_field("createAt"));
14979 }
14980 create_at__ =
14981 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14982 ;
14983 }
14984 GeneratedField::CompactTask => {
14985 if event__.is_some() {
14986 return Err(serde::de::Error::duplicate_field("compactTask"));
14987 }
14988 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
14989;
14990 }
14991 GeneratedField::VacuumTask => {
14992 if event__.is_some() {
14993 return Err(serde::de::Error::duplicate_field("vacuumTask"));
14994 }
14995 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
14996;
14997 }
14998 GeneratedField::FullScanTask => {
14999 if event__.is_some() {
15000 return Err(serde::de::Error::duplicate_field("fullScanTask"));
15001 }
15002 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
15003;
15004 }
15005 GeneratedField::ValidationTask => {
15006 if event__.is_some() {
15007 return Err(serde::de::Error::duplicate_field("validationTask"));
15008 }
15009 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
15010;
15011 }
15012 GeneratedField::CancelCompactTask => {
15013 if event__.is_some() {
15014 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
15015 }
15016 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
15017;
15018 }
15019 GeneratedField::PullTaskAck => {
15020 if event__.is_some() {
15021 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
15022 }
15023 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
15024;
15025 }
15026 }
15027 }
15028 Ok(SubscribeCompactionEventResponse {
15029 create_at: create_at__.unwrap_or_default(),
15030 event: event__,
15031 })
15032 }
15033 }
15034 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
15035 }
15036}
15037impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
15038 #[allow(deprecated)]
15039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15040 where
15041 S: serde::Serializer,
15042 {
15043 use serde::ser::SerializeStruct;
15044 let len = 0;
15045 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
15046 struct_ser.end()
15047 }
15048}
15049impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
15050 #[allow(deprecated)]
15051 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15052 where
15053 D: serde::Deserializer<'de>,
15054 {
15055 const FIELDS: &[&str] = &[
15056 ];
15057
15058 #[allow(clippy::enum_variant_names)]
15059 enum GeneratedField {
15060 }
15061 impl<'de> serde::Deserialize<'de> for GeneratedField {
15062 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15063 where
15064 D: serde::Deserializer<'de>,
15065 {
15066 struct GeneratedVisitor;
15067
15068 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15069 type Value = GeneratedField;
15070
15071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15072 write!(formatter, "expected one of: {:?}", &FIELDS)
15073 }
15074
15075 #[allow(unused_variables)]
15076 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15077 where
15078 E: serde::de::Error,
15079 {
15080 Err(serde::de::Error::unknown_field(value, FIELDS))
15081 }
15082 }
15083 deserializer.deserialize_identifier(GeneratedVisitor)
15084 }
15085 }
15086 struct GeneratedVisitor;
15087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15088 type Value = subscribe_compaction_event_response::PullTaskAck;
15089
15090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15091 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
15092 }
15093
15094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
15095 where
15096 V: serde::de::MapAccess<'de>,
15097 {
15098 while map_.next_key::<GeneratedField>()?.is_some() {
15099 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15100 }
15101 Ok(subscribe_compaction_event_response::PullTaskAck {
15102 })
15103 }
15104 }
15105 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
15106 }
15107}
15108impl serde::Serialize for TableChangeLog {
15109 #[allow(deprecated)]
15110 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15111 where
15112 S: serde::Serializer,
15113 {
15114 use serde::ser::SerializeStruct;
15115 let mut len = 0;
15116 if !self.change_logs.is_empty() {
15117 len += 1;
15118 }
15119 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
15120 if !self.change_logs.is_empty() {
15121 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
15122 }
15123 struct_ser.end()
15124 }
15125}
15126impl<'de> serde::Deserialize<'de> for TableChangeLog {
15127 #[allow(deprecated)]
15128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15129 where
15130 D: serde::Deserializer<'de>,
15131 {
15132 const FIELDS: &[&str] = &[
15133 "change_logs",
15134 "changeLogs",
15135 ];
15136
15137 #[allow(clippy::enum_variant_names)]
15138 enum GeneratedField {
15139 ChangeLogs,
15140 }
15141 impl<'de> serde::Deserialize<'de> for GeneratedField {
15142 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15143 where
15144 D: serde::Deserializer<'de>,
15145 {
15146 struct GeneratedVisitor;
15147
15148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15149 type Value = GeneratedField;
15150
15151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15152 write!(formatter, "expected one of: {:?}", &FIELDS)
15153 }
15154
15155 #[allow(unused_variables)]
15156 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15157 where
15158 E: serde::de::Error,
15159 {
15160 match value {
15161 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
15162 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15163 }
15164 }
15165 }
15166 deserializer.deserialize_identifier(GeneratedVisitor)
15167 }
15168 }
15169 struct GeneratedVisitor;
15170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15171 type Value = TableChangeLog;
15172
15173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15174 formatter.write_str("struct hummock.TableChangeLog")
15175 }
15176
15177 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
15178 where
15179 V: serde::de::MapAccess<'de>,
15180 {
15181 let mut change_logs__ = None;
15182 while let Some(k) = map_.next_key()? {
15183 match k {
15184 GeneratedField::ChangeLogs => {
15185 if change_logs__.is_some() {
15186 return Err(serde::de::Error::duplicate_field("changeLogs"));
15187 }
15188 change_logs__ = Some(map_.next_value()?);
15189 }
15190 }
15191 }
15192 Ok(TableChangeLog {
15193 change_logs: change_logs__.unwrap_or_default(),
15194 })
15195 }
15196 }
15197 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
15198 }
15199}
15200impl serde::Serialize for TableOption {
15201 #[allow(deprecated)]
15202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15203 where
15204 S: serde::Serializer,
15205 {
15206 use serde::ser::SerializeStruct;
15207 let mut len = 0;
15208 if self.retention_seconds.is_some() {
15209 len += 1;
15210 }
15211 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
15212 if let Some(v) = self.retention_seconds.as_ref() {
15213 struct_ser.serialize_field("retentionSeconds", v)?;
15214 }
15215 struct_ser.end()
15216 }
15217}
15218impl<'de> serde::Deserialize<'de> for TableOption {
15219 #[allow(deprecated)]
15220 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15221 where
15222 D: serde::Deserializer<'de>,
15223 {
15224 const FIELDS: &[&str] = &[
15225 "retention_seconds",
15226 "retentionSeconds",
15227 ];
15228
15229 #[allow(clippy::enum_variant_names)]
15230 enum GeneratedField {
15231 RetentionSeconds,
15232 }
15233 impl<'de> serde::Deserialize<'de> for GeneratedField {
15234 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15235 where
15236 D: serde::Deserializer<'de>,
15237 {
15238 struct GeneratedVisitor;
15239
15240 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15241 type Value = GeneratedField;
15242
15243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15244 write!(formatter, "expected one of: {:?}", &FIELDS)
15245 }
15246
15247 #[allow(unused_variables)]
15248 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15249 where
15250 E: serde::de::Error,
15251 {
15252 match value {
15253 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
15254 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15255 }
15256 }
15257 }
15258 deserializer.deserialize_identifier(GeneratedVisitor)
15259 }
15260 }
15261 struct GeneratedVisitor;
15262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15263 type Value = TableOption;
15264
15265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15266 formatter.write_str("struct hummock.TableOption")
15267 }
15268
15269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
15270 where
15271 V: serde::de::MapAccess<'de>,
15272 {
15273 let mut retention_seconds__ = None;
15274 while let Some(k) = map_.next_key()? {
15275 match k {
15276 GeneratedField::RetentionSeconds => {
15277 if retention_seconds__.is_some() {
15278 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
15279 }
15280 retention_seconds__ =
15281 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15282 ;
15283 }
15284 }
15285 }
15286 Ok(TableOption {
15287 retention_seconds: retention_seconds__,
15288 })
15289 }
15290 }
15291 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
15292 }
15293}
15294impl serde::Serialize for TableSchema {
15295 #[allow(deprecated)]
15296 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15297 where
15298 S: serde::Serializer,
15299 {
15300 use serde::ser::SerializeStruct;
15301 let mut len = 0;
15302 if !self.column_ids.is_empty() {
15303 len += 1;
15304 }
15305 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
15306 if !self.column_ids.is_empty() {
15307 struct_ser.serialize_field("columnIds", &self.column_ids)?;
15308 }
15309 struct_ser.end()
15310 }
15311}
15312impl<'de> serde::Deserialize<'de> for TableSchema {
15313 #[allow(deprecated)]
15314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15315 where
15316 D: serde::Deserializer<'de>,
15317 {
15318 const FIELDS: &[&str] = &[
15319 "column_ids",
15320 "columnIds",
15321 ];
15322
15323 #[allow(clippy::enum_variant_names)]
15324 enum GeneratedField {
15325 ColumnIds,
15326 }
15327 impl<'de> serde::Deserialize<'de> for GeneratedField {
15328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15329 where
15330 D: serde::Deserializer<'de>,
15331 {
15332 struct GeneratedVisitor;
15333
15334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15335 type Value = GeneratedField;
15336
15337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15338 write!(formatter, "expected one of: {:?}", &FIELDS)
15339 }
15340
15341 #[allow(unused_variables)]
15342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15343 where
15344 E: serde::de::Error,
15345 {
15346 match value {
15347 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
15348 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15349 }
15350 }
15351 }
15352 deserializer.deserialize_identifier(GeneratedVisitor)
15353 }
15354 }
15355 struct GeneratedVisitor;
15356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15357 type Value = TableSchema;
15358
15359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15360 formatter.write_str("struct hummock.TableSchema")
15361 }
15362
15363 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
15364 where
15365 V: serde::de::MapAccess<'de>,
15366 {
15367 let mut column_ids__ = None;
15368 while let Some(k) = map_.next_key()? {
15369 match k {
15370 GeneratedField::ColumnIds => {
15371 if column_ids__.is_some() {
15372 return Err(serde::de::Error::duplicate_field("columnIds"));
15373 }
15374 column_ids__ =
15375 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15376 .into_iter().map(|x| x.0).collect())
15377 ;
15378 }
15379 }
15380 }
15381 Ok(TableSchema {
15382 column_ids: column_ids__.unwrap_or_default(),
15383 })
15384 }
15385 }
15386 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
15387 }
15388}
15389impl serde::Serialize for TableStats {
15390 #[allow(deprecated)]
15391 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15392 where
15393 S: serde::Serializer,
15394 {
15395 use serde::ser::SerializeStruct;
15396 let mut len = 0;
15397 if self.total_key_size != 0 {
15398 len += 1;
15399 }
15400 if self.total_value_size != 0 {
15401 len += 1;
15402 }
15403 if self.total_key_count != 0 {
15404 len += 1;
15405 }
15406 if self.total_compressed_size != 0 {
15407 len += 1;
15408 }
15409 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
15410 if self.total_key_size != 0 {
15411 #[allow(clippy::needless_borrow)]
15412 #[allow(clippy::needless_borrows_for_generic_args)]
15413 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
15414 }
15415 if self.total_value_size != 0 {
15416 #[allow(clippy::needless_borrow)]
15417 #[allow(clippy::needless_borrows_for_generic_args)]
15418 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
15419 }
15420 if self.total_key_count != 0 {
15421 #[allow(clippy::needless_borrow)]
15422 #[allow(clippy::needless_borrows_for_generic_args)]
15423 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
15424 }
15425 if self.total_compressed_size != 0 {
15426 #[allow(clippy::needless_borrow)]
15427 #[allow(clippy::needless_borrows_for_generic_args)]
15428 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
15429 }
15430 struct_ser.end()
15431 }
15432}
15433impl<'de> serde::Deserialize<'de> for TableStats {
15434 #[allow(deprecated)]
15435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15436 where
15437 D: serde::Deserializer<'de>,
15438 {
15439 const FIELDS: &[&str] = &[
15440 "total_key_size",
15441 "totalKeySize",
15442 "total_value_size",
15443 "totalValueSize",
15444 "total_key_count",
15445 "totalKeyCount",
15446 "total_compressed_size",
15447 "totalCompressedSize",
15448 ];
15449
15450 #[allow(clippy::enum_variant_names)]
15451 enum GeneratedField {
15452 TotalKeySize,
15453 TotalValueSize,
15454 TotalKeyCount,
15455 TotalCompressedSize,
15456 }
15457 impl<'de> serde::Deserialize<'de> for GeneratedField {
15458 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15459 where
15460 D: serde::Deserializer<'de>,
15461 {
15462 struct GeneratedVisitor;
15463
15464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15465 type Value = GeneratedField;
15466
15467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15468 write!(formatter, "expected one of: {:?}", &FIELDS)
15469 }
15470
15471 #[allow(unused_variables)]
15472 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15473 where
15474 E: serde::de::Error,
15475 {
15476 match value {
15477 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
15478 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
15479 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
15480 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
15481 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15482 }
15483 }
15484 }
15485 deserializer.deserialize_identifier(GeneratedVisitor)
15486 }
15487 }
15488 struct GeneratedVisitor;
15489 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15490 type Value = TableStats;
15491
15492 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15493 formatter.write_str("struct hummock.TableStats")
15494 }
15495
15496 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
15497 where
15498 V: serde::de::MapAccess<'de>,
15499 {
15500 let mut total_key_size__ = None;
15501 let mut total_value_size__ = None;
15502 let mut total_key_count__ = None;
15503 let mut total_compressed_size__ = None;
15504 while let Some(k) = map_.next_key()? {
15505 match k {
15506 GeneratedField::TotalKeySize => {
15507 if total_key_size__.is_some() {
15508 return Err(serde::de::Error::duplicate_field("totalKeySize"));
15509 }
15510 total_key_size__ =
15511 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15512 ;
15513 }
15514 GeneratedField::TotalValueSize => {
15515 if total_value_size__.is_some() {
15516 return Err(serde::de::Error::duplicate_field("totalValueSize"));
15517 }
15518 total_value_size__ =
15519 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15520 ;
15521 }
15522 GeneratedField::TotalKeyCount => {
15523 if total_key_count__.is_some() {
15524 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
15525 }
15526 total_key_count__ =
15527 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15528 ;
15529 }
15530 GeneratedField::TotalCompressedSize => {
15531 if total_compressed_size__.is_some() {
15532 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
15533 }
15534 total_compressed_size__ =
15535 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15536 ;
15537 }
15538 }
15539 }
15540 Ok(TableStats {
15541 total_key_size: total_key_size__.unwrap_or_default(),
15542 total_value_size: total_value_size__.unwrap_or_default(),
15543 total_key_count: total_key_count__.unwrap_or_default(),
15544 total_compressed_size: total_compressed_size__.unwrap_or_default(),
15545 })
15546 }
15547 }
15548 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
15549 }
15550}
15551impl serde::Serialize for TableWatermarks {
15552 #[allow(deprecated)]
15553 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15554 where
15555 S: serde::Serializer,
15556 {
15557 use serde::ser::SerializeStruct;
15558 let mut len = 0;
15559 if !self.epoch_watermarks.is_empty() {
15560 len += 1;
15561 }
15562 if self.is_ascending {
15563 len += 1;
15564 }
15565 if self.is_non_pk_prefix {
15566 len += 1;
15567 }
15568 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
15569 if !self.epoch_watermarks.is_empty() {
15570 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
15571 }
15572 if self.is_ascending {
15573 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
15574 }
15575 if self.is_non_pk_prefix {
15576 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
15577 }
15578 struct_ser.end()
15579 }
15580}
15581impl<'de> serde::Deserialize<'de> for TableWatermarks {
15582 #[allow(deprecated)]
15583 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15584 where
15585 D: serde::Deserializer<'de>,
15586 {
15587 const FIELDS: &[&str] = &[
15588 "epoch_watermarks",
15589 "epochWatermarks",
15590 "is_ascending",
15591 "isAscending",
15592 "is_non_pk_prefix",
15593 "isNonPkPrefix",
15594 ];
15595
15596 #[allow(clippy::enum_variant_names)]
15597 enum GeneratedField {
15598 EpochWatermarks,
15599 IsAscending,
15600 IsNonPkPrefix,
15601 }
15602 impl<'de> serde::Deserialize<'de> for GeneratedField {
15603 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15604 where
15605 D: serde::Deserializer<'de>,
15606 {
15607 struct GeneratedVisitor;
15608
15609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15610 type Value = GeneratedField;
15611
15612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15613 write!(formatter, "expected one of: {:?}", &FIELDS)
15614 }
15615
15616 #[allow(unused_variables)]
15617 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15618 where
15619 E: serde::de::Error,
15620 {
15621 match value {
15622 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
15623 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
15624 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
15625 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15626 }
15627 }
15628 }
15629 deserializer.deserialize_identifier(GeneratedVisitor)
15630 }
15631 }
15632 struct GeneratedVisitor;
15633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15634 type Value = TableWatermarks;
15635
15636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15637 formatter.write_str("struct hummock.TableWatermarks")
15638 }
15639
15640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
15641 where
15642 V: serde::de::MapAccess<'de>,
15643 {
15644 let mut epoch_watermarks__ = None;
15645 let mut is_ascending__ = None;
15646 let mut is_non_pk_prefix__ = None;
15647 while let Some(k) = map_.next_key()? {
15648 match k {
15649 GeneratedField::EpochWatermarks => {
15650 if epoch_watermarks__.is_some() {
15651 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
15652 }
15653 epoch_watermarks__ = Some(map_.next_value()?);
15654 }
15655 GeneratedField::IsAscending => {
15656 if is_ascending__.is_some() {
15657 return Err(serde::de::Error::duplicate_field("isAscending"));
15658 }
15659 is_ascending__ = Some(map_.next_value()?);
15660 }
15661 GeneratedField::IsNonPkPrefix => {
15662 if is_non_pk_prefix__.is_some() {
15663 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
15664 }
15665 is_non_pk_prefix__ = Some(map_.next_value()?);
15666 }
15667 }
15668 }
15669 Ok(TableWatermarks {
15670 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
15671 is_ascending: is_ascending__.unwrap_or_default(),
15672 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
15673 })
15674 }
15675 }
15676 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
15677 }
15678}
15679impl serde::Serialize for table_watermarks::EpochNewWatermarks {
15680 #[allow(deprecated)]
15681 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15682 where
15683 S: serde::Serializer,
15684 {
15685 use serde::ser::SerializeStruct;
15686 let mut len = 0;
15687 if !self.watermarks.is_empty() {
15688 len += 1;
15689 }
15690 if self.epoch != 0 {
15691 len += 1;
15692 }
15693 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
15694 if !self.watermarks.is_empty() {
15695 struct_ser.serialize_field("watermarks", &self.watermarks)?;
15696 }
15697 if self.epoch != 0 {
15698 #[allow(clippy::needless_borrow)]
15699 #[allow(clippy::needless_borrows_for_generic_args)]
15700 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
15701 }
15702 struct_ser.end()
15703 }
15704}
15705impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
15706 #[allow(deprecated)]
15707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15708 where
15709 D: serde::Deserializer<'de>,
15710 {
15711 const FIELDS: &[&str] = &[
15712 "watermarks",
15713 "epoch",
15714 ];
15715
15716 #[allow(clippy::enum_variant_names)]
15717 enum GeneratedField {
15718 Watermarks,
15719 Epoch,
15720 }
15721 impl<'de> serde::Deserialize<'de> for GeneratedField {
15722 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15723 where
15724 D: serde::Deserializer<'de>,
15725 {
15726 struct GeneratedVisitor;
15727
15728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15729 type Value = GeneratedField;
15730
15731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15732 write!(formatter, "expected one of: {:?}", &FIELDS)
15733 }
15734
15735 #[allow(unused_variables)]
15736 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15737 where
15738 E: serde::de::Error,
15739 {
15740 match value {
15741 "watermarks" => Ok(GeneratedField::Watermarks),
15742 "epoch" => Ok(GeneratedField::Epoch),
15743 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15744 }
15745 }
15746 }
15747 deserializer.deserialize_identifier(GeneratedVisitor)
15748 }
15749 }
15750 struct GeneratedVisitor;
15751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15752 type Value = table_watermarks::EpochNewWatermarks;
15753
15754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15755 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
15756 }
15757
15758 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
15759 where
15760 V: serde::de::MapAccess<'de>,
15761 {
15762 let mut watermarks__ = None;
15763 let mut epoch__ = None;
15764 while let Some(k) = map_.next_key()? {
15765 match k {
15766 GeneratedField::Watermarks => {
15767 if watermarks__.is_some() {
15768 return Err(serde::de::Error::duplicate_field("watermarks"));
15769 }
15770 watermarks__ = Some(map_.next_value()?);
15771 }
15772 GeneratedField::Epoch => {
15773 if epoch__.is_some() {
15774 return Err(serde::de::Error::duplicate_field("epoch"));
15775 }
15776 epoch__ =
15777 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15778 ;
15779 }
15780 }
15781 }
15782 Ok(table_watermarks::EpochNewWatermarks {
15783 watermarks: watermarks__.unwrap_or_default(),
15784 epoch: epoch__.unwrap_or_default(),
15785 })
15786 }
15787 }
15788 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
15789 }
15790}
15791impl serde::Serialize for TriggerCompactionDeterministicRequest {
15792 #[allow(deprecated)]
15793 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15794 where
15795 S: serde::Serializer,
15796 {
15797 use serde::ser::SerializeStruct;
15798 let mut len = 0;
15799 if self.version_id != 0 {
15800 len += 1;
15801 }
15802 if !self.compaction_groups.is_empty() {
15803 len += 1;
15804 }
15805 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
15806 if self.version_id != 0 {
15807 #[allow(clippy::needless_borrow)]
15808 #[allow(clippy::needless_borrows_for_generic_args)]
15809 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
15810 }
15811 if !self.compaction_groups.is_empty() {
15812 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15813 }
15814 struct_ser.end()
15815 }
15816}
15817impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
15818 #[allow(deprecated)]
15819 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15820 where
15821 D: serde::Deserializer<'de>,
15822 {
15823 const FIELDS: &[&str] = &[
15824 "version_id",
15825 "versionId",
15826 "compaction_groups",
15827 "compactionGroups",
15828 ];
15829
15830 #[allow(clippy::enum_variant_names)]
15831 enum GeneratedField {
15832 VersionId,
15833 CompactionGroups,
15834 }
15835 impl<'de> serde::Deserialize<'de> for GeneratedField {
15836 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15837 where
15838 D: serde::Deserializer<'de>,
15839 {
15840 struct GeneratedVisitor;
15841
15842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15843 type Value = GeneratedField;
15844
15845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15846 write!(formatter, "expected one of: {:?}", &FIELDS)
15847 }
15848
15849 #[allow(unused_variables)]
15850 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15851 where
15852 E: serde::de::Error,
15853 {
15854 match value {
15855 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
15856 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
15857 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15858 }
15859 }
15860 }
15861 deserializer.deserialize_identifier(GeneratedVisitor)
15862 }
15863 }
15864 struct GeneratedVisitor;
15865 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15866 type Value = TriggerCompactionDeterministicRequest;
15867
15868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15869 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
15870 }
15871
15872 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
15873 where
15874 V: serde::de::MapAccess<'de>,
15875 {
15876 let mut version_id__ = None;
15877 let mut compaction_groups__ = None;
15878 while let Some(k) = map_.next_key()? {
15879 match k {
15880 GeneratedField::VersionId => {
15881 if version_id__.is_some() {
15882 return Err(serde::de::Error::duplicate_field("versionId"));
15883 }
15884 version_id__ =
15885 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15886 ;
15887 }
15888 GeneratedField::CompactionGroups => {
15889 if compaction_groups__.is_some() {
15890 return Err(serde::de::Error::duplicate_field("compactionGroups"));
15891 }
15892 compaction_groups__ =
15893 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15894 .into_iter().map(|x| x.0).collect())
15895 ;
15896 }
15897 }
15898 }
15899 Ok(TriggerCompactionDeterministicRequest {
15900 version_id: version_id__.unwrap_or_default(),
15901 compaction_groups: compaction_groups__.unwrap_or_default(),
15902 })
15903 }
15904 }
15905 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
15906 }
15907}
15908impl serde::Serialize for TriggerCompactionDeterministicResponse {
15909 #[allow(deprecated)]
15910 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15911 where
15912 S: serde::Serializer,
15913 {
15914 use serde::ser::SerializeStruct;
15915 let len = 0;
15916 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
15917 struct_ser.end()
15918 }
15919}
15920impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
15921 #[allow(deprecated)]
15922 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15923 where
15924 D: serde::Deserializer<'de>,
15925 {
15926 const FIELDS: &[&str] = &[
15927 ];
15928
15929 #[allow(clippy::enum_variant_names)]
15930 enum GeneratedField {
15931 }
15932 impl<'de> serde::Deserialize<'de> for GeneratedField {
15933 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15934 where
15935 D: serde::Deserializer<'de>,
15936 {
15937 struct GeneratedVisitor;
15938
15939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15940 type Value = GeneratedField;
15941
15942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15943 write!(formatter, "expected one of: {:?}", &FIELDS)
15944 }
15945
15946 #[allow(unused_variables)]
15947 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15948 where
15949 E: serde::de::Error,
15950 {
15951 Err(serde::de::Error::unknown_field(value, FIELDS))
15952 }
15953 }
15954 deserializer.deserialize_identifier(GeneratedVisitor)
15955 }
15956 }
15957 struct GeneratedVisitor;
15958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15959 type Value = TriggerCompactionDeterministicResponse;
15960
15961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15962 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
15963 }
15964
15965 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
15966 where
15967 V: serde::de::MapAccess<'de>,
15968 {
15969 while map_.next_key::<GeneratedField>()?.is_some() {
15970 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15971 }
15972 Ok(TriggerCompactionDeterministicResponse {
15973 })
15974 }
15975 }
15976 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
15977 }
15978}
15979impl serde::Serialize for TriggerFullGcRequest {
15980 #[allow(deprecated)]
15981 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15982 where
15983 S: serde::Serializer,
15984 {
15985 use serde::ser::SerializeStruct;
15986 let mut len = 0;
15987 if self.sst_retention_time_sec != 0 {
15988 len += 1;
15989 }
15990 if self.prefix.is_some() {
15991 len += 1;
15992 }
15993 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
15994 if self.sst_retention_time_sec != 0 {
15995 #[allow(clippy::needless_borrow)]
15996 #[allow(clippy::needless_borrows_for_generic_args)]
15997 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
15998 }
15999 if let Some(v) = self.prefix.as_ref() {
16000 struct_ser.serialize_field("prefix", v)?;
16001 }
16002 struct_ser.end()
16003 }
16004}
16005impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
16006 #[allow(deprecated)]
16007 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16008 where
16009 D: serde::Deserializer<'de>,
16010 {
16011 const FIELDS: &[&str] = &[
16012 "sst_retention_time_sec",
16013 "sstRetentionTimeSec",
16014 "prefix",
16015 ];
16016
16017 #[allow(clippy::enum_variant_names)]
16018 enum GeneratedField {
16019 SstRetentionTimeSec,
16020 Prefix,
16021 }
16022 impl<'de> serde::Deserialize<'de> for GeneratedField {
16023 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16024 where
16025 D: serde::Deserializer<'de>,
16026 {
16027 struct GeneratedVisitor;
16028
16029 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16030 type Value = GeneratedField;
16031
16032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16033 write!(formatter, "expected one of: {:?}", &FIELDS)
16034 }
16035
16036 #[allow(unused_variables)]
16037 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16038 where
16039 E: serde::de::Error,
16040 {
16041 match value {
16042 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
16043 "prefix" => Ok(GeneratedField::Prefix),
16044 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16045 }
16046 }
16047 }
16048 deserializer.deserialize_identifier(GeneratedVisitor)
16049 }
16050 }
16051 struct GeneratedVisitor;
16052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16053 type Value = TriggerFullGcRequest;
16054
16055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16056 formatter.write_str("struct hummock.TriggerFullGCRequest")
16057 }
16058
16059 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
16060 where
16061 V: serde::de::MapAccess<'de>,
16062 {
16063 let mut sst_retention_time_sec__ = None;
16064 let mut prefix__ = None;
16065 while let Some(k) = map_.next_key()? {
16066 match k {
16067 GeneratedField::SstRetentionTimeSec => {
16068 if sst_retention_time_sec__.is_some() {
16069 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
16070 }
16071 sst_retention_time_sec__ =
16072 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16073 ;
16074 }
16075 GeneratedField::Prefix => {
16076 if prefix__.is_some() {
16077 return Err(serde::de::Error::duplicate_field("prefix"));
16078 }
16079 prefix__ = map_.next_value()?;
16080 }
16081 }
16082 }
16083 Ok(TriggerFullGcRequest {
16084 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
16085 prefix: prefix__,
16086 })
16087 }
16088 }
16089 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
16090 }
16091}
16092impl serde::Serialize for TriggerFullGcResponse {
16093 #[allow(deprecated)]
16094 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16095 where
16096 S: serde::Serializer,
16097 {
16098 use serde::ser::SerializeStruct;
16099 let mut len = 0;
16100 if self.status.is_some() {
16101 len += 1;
16102 }
16103 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
16104 if let Some(v) = self.status.as_ref() {
16105 struct_ser.serialize_field("status", v)?;
16106 }
16107 struct_ser.end()
16108 }
16109}
16110impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
16111 #[allow(deprecated)]
16112 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16113 where
16114 D: serde::Deserializer<'de>,
16115 {
16116 const FIELDS: &[&str] = &[
16117 "status",
16118 ];
16119
16120 #[allow(clippy::enum_variant_names)]
16121 enum GeneratedField {
16122 Status,
16123 }
16124 impl<'de> serde::Deserialize<'de> for GeneratedField {
16125 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16126 where
16127 D: serde::Deserializer<'de>,
16128 {
16129 struct GeneratedVisitor;
16130
16131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16132 type Value = GeneratedField;
16133
16134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16135 write!(formatter, "expected one of: {:?}", &FIELDS)
16136 }
16137
16138 #[allow(unused_variables)]
16139 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16140 where
16141 E: serde::de::Error,
16142 {
16143 match value {
16144 "status" => Ok(GeneratedField::Status),
16145 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16146 }
16147 }
16148 }
16149 deserializer.deserialize_identifier(GeneratedVisitor)
16150 }
16151 }
16152 struct GeneratedVisitor;
16153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16154 type Value = TriggerFullGcResponse;
16155
16156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16157 formatter.write_str("struct hummock.TriggerFullGCResponse")
16158 }
16159
16160 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
16161 where
16162 V: serde::de::MapAccess<'de>,
16163 {
16164 let mut status__ = None;
16165 while let Some(k) = map_.next_key()? {
16166 match k {
16167 GeneratedField::Status => {
16168 if status__.is_some() {
16169 return Err(serde::de::Error::duplicate_field("status"));
16170 }
16171 status__ = map_.next_value()?;
16172 }
16173 }
16174 }
16175 Ok(TriggerFullGcResponse {
16176 status: status__,
16177 })
16178 }
16179 }
16180 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
16181 }
16182}
16183impl serde::Serialize for TriggerManualCompactionRequest {
16184 #[allow(deprecated)]
16185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16186 where
16187 S: serde::Serializer,
16188 {
16189 use serde::ser::SerializeStruct;
16190 let mut len = 0;
16191 if self.compaction_group_id != 0 {
16192 len += 1;
16193 }
16194 if self.key_range.is_some() {
16195 len += 1;
16196 }
16197 if self.table_id != 0 {
16198 len += 1;
16199 }
16200 if self.level != 0 {
16201 len += 1;
16202 }
16203 if !self.sst_ids.is_empty() {
16204 len += 1;
16205 }
16206 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
16207 if self.compaction_group_id != 0 {
16208 #[allow(clippy::needless_borrow)]
16209 #[allow(clippy::needless_borrows_for_generic_args)]
16210 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
16211 }
16212 if let Some(v) = self.key_range.as_ref() {
16213 struct_ser.serialize_field("keyRange", v)?;
16214 }
16215 if self.table_id != 0 {
16216 struct_ser.serialize_field("tableId", &self.table_id)?;
16217 }
16218 if self.level != 0 {
16219 struct_ser.serialize_field("level", &self.level)?;
16220 }
16221 if !self.sst_ids.is_empty() {
16222 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16223 }
16224 struct_ser.end()
16225 }
16226}
16227impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
16228 #[allow(deprecated)]
16229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16230 where
16231 D: serde::Deserializer<'de>,
16232 {
16233 const FIELDS: &[&str] = &[
16234 "compaction_group_id",
16235 "compactionGroupId",
16236 "key_range",
16237 "keyRange",
16238 "table_id",
16239 "tableId",
16240 "level",
16241 "sst_ids",
16242 "sstIds",
16243 ];
16244
16245 #[allow(clippy::enum_variant_names)]
16246 enum GeneratedField {
16247 CompactionGroupId,
16248 KeyRange,
16249 TableId,
16250 Level,
16251 SstIds,
16252 }
16253 impl<'de> serde::Deserialize<'de> for GeneratedField {
16254 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16255 where
16256 D: serde::Deserializer<'de>,
16257 {
16258 struct GeneratedVisitor;
16259
16260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16261 type Value = GeneratedField;
16262
16263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16264 write!(formatter, "expected one of: {:?}", &FIELDS)
16265 }
16266
16267 #[allow(unused_variables)]
16268 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16269 where
16270 E: serde::de::Error,
16271 {
16272 match value {
16273 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
16274 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
16275 "tableId" | "table_id" => Ok(GeneratedField::TableId),
16276 "level" => Ok(GeneratedField::Level),
16277 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
16278 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16279 }
16280 }
16281 }
16282 deserializer.deserialize_identifier(GeneratedVisitor)
16283 }
16284 }
16285 struct GeneratedVisitor;
16286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16287 type Value = TriggerManualCompactionRequest;
16288
16289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16290 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
16291 }
16292
16293 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
16294 where
16295 V: serde::de::MapAccess<'de>,
16296 {
16297 let mut compaction_group_id__ = None;
16298 let mut key_range__ = None;
16299 let mut table_id__ = None;
16300 let mut level__ = None;
16301 let mut sst_ids__ = None;
16302 while let Some(k) = map_.next_key()? {
16303 match k {
16304 GeneratedField::CompactionGroupId => {
16305 if compaction_group_id__.is_some() {
16306 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
16307 }
16308 compaction_group_id__ =
16309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16310 ;
16311 }
16312 GeneratedField::KeyRange => {
16313 if key_range__.is_some() {
16314 return Err(serde::de::Error::duplicate_field("keyRange"));
16315 }
16316 key_range__ = map_.next_value()?;
16317 }
16318 GeneratedField::TableId => {
16319 if table_id__.is_some() {
16320 return Err(serde::de::Error::duplicate_field("tableId"));
16321 }
16322 table_id__ =
16323 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16324 ;
16325 }
16326 GeneratedField::Level => {
16327 if level__.is_some() {
16328 return Err(serde::de::Error::duplicate_field("level"));
16329 }
16330 level__ =
16331 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16332 ;
16333 }
16334 GeneratedField::SstIds => {
16335 if sst_ids__.is_some() {
16336 return Err(serde::de::Error::duplicate_field("sstIds"));
16337 }
16338 sst_ids__ =
16339 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16340 .into_iter().map(|x| x.0).collect())
16341 ;
16342 }
16343 }
16344 }
16345 Ok(TriggerManualCompactionRequest {
16346 compaction_group_id: compaction_group_id__.unwrap_or_default(),
16347 key_range: key_range__,
16348 table_id: table_id__.unwrap_or_default(),
16349 level: level__.unwrap_or_default(),
16350 sst_ids: sst_ids__.unwrap_or_default(),
16351 })
16352 }
16353 }
16354 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
16355 }
16356}
16357impl serde::Serialize for TriggerManualCompactionResponse {
16358 #[allow(deprecated)]
16359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16360 where
16361 S: serde::Serializer,
16362 {
16363 use serde::ser::SerializeStruct;
16364 let mut len = 0;
16365 if self.status.is_some() {
16366 len += 1;
16367 }
16368 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
16369 if let Some(v) = self.status.as_ref() {
16370 struct_ser.serialize_field("status", v)?;
16371 }
16372 struct_ser.end()
16373 }
16374}
16375impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
16376 #[allow(deprecated)]
16377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16378 where
16379 D: serde::Deserializer<'de>,
16380 {
16381 const FIELDS: &[&str] = &[
16382 "status",
16383 ];
16384
16385 #[allow(clippy::enum_variant_names)]
16386 enum GeneratedField {
16387 Status,
16388 }
16389 impl<'de> serde::Deserialize<'de> for GeneratedField {
16390 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16391 where
16392 D: serde::Deserializer<'de>,
16393 {
16394 struct GeneratedVisitor;
16395
16396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16397 type Value = GeneratedField;
16398
16399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16400 write!(formatter, "expected one of: {:?}", &FIELDS)
16401 }
16402
16403 #[allow(unused_variables)]
16404 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16405 where
16406 E: serde::de::Error,
16407 {
16408 match value {
16409 "status" => Ok(GeneratedField::Status),
16410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16411 }
16412 }
16413 }
16414 deserializer.deserialize_identifier(GeneratedVisitor)
16415 }
16416 }
16417 struct GeneratedVisitor;
16418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16419 type Value = TriggerManualCompactionResponse;
16420
16421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16422 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
16423 }
16424
16425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
16426 where
16427 V: serde::de::MapAccess<'de>,
16428 {
16429 let mut status__ = None;
16430 while let Some(k) = map_.next_key()? {
16431 match k {
16432 GeneratedField::Status => {
16433 if status__.is_some() {
16434 return Err(serde::de::Error::duplicate_field("status"));
16435 }
16436 status__ = map_.next_value()?;
16437 }
16438 }
16439 }
16440 Ok(TriggerManualCompactionResponse {
16441 status: status__,
16442 })
16443 }
16444 }
16445 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
16446 }
16447}
16448impl serde::Serialize for TruncateTables {
16449 #[allow(deprecated)]
16450 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16451 where
16452 S: serde::Serializer,
16453 {
16454 use serde::ser::SerializeStruct;
16455 let mut len = 0;
16456 if !self.table_ids.is_empty() {
16457 len += 1;
16458 }
16459 let mut struct_ser = serializer.serialize_struct("hummock.TruncateTables", len)?;
16460 if !self.table_ids.is_empty() {
16461 struct_ser.serialize_field("tableIds", &self.table_ids)?;
16462 }
16463 struct_ser.end()
16464 }
16465}
16466impl<'de> serde::Deserialize<'de> for TruncateTables {
16467 #[allow(deprecated)]
16468 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16469 where
16470 D: serde::Deserializer<'de>,
16471 {
16472 const FIELDS: &[&str] = &[
16473 "table_ids",
16474 "tableIds",
16475 ];
16476
16477 #[allow(clippy::enum_variant_names)]
16478 enum GeneratedField {
16479 TableIds,
16480 }
16481 impl<'de> serde::Deserialize<'de> for GeneratedField {
16482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16483 where
16484 D: serde::Deserializer<'de>,
16485 {
16486 struct GeneratedVisitor;
16487
16488 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16489 type Value = GeneratedField;
16490
16491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16492 write!(formatter, "expected one of: {:?}", &FIELDS)
16493 }
16494
16495 #[allow(unused_variables)]
16496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16497 where
16498 E: serde::de::Error,
16499 {
16500 match value {
16501 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
16502 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16503 }
16504 }
16505 }
16506 deserializer.deserialize_identifier(GeneratedVisitor)
16507 }
16508 }
16509 struct GeneratedVisitor;
16510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16511 type Value = TruncateTables;
16512
16513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16514 formatter.write_str("struct hummock.TruncateTables")
16515 }
16516
16517 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TruncateTables, V::Error>
16518 where
16519 V: serde::de::MapAccess<'de>,
16520 {
16521 let mut table_ids__ = None;
16522 while let Some(k) = map_.next_key()? {
16523 match k {
16524 GeneratedField::TableIds => {
16525 if table_ids__.is_some() {
16526 return Err(serde::de::Error::duplicate_field("tableIds"));
16527 }
16528 table_ids__ =
16529 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16530 .into_iter().map(|x| x.0).collect())
16531 ;
16532 }
16533 }
16534 }
16535 Ok(TruncateTables {
16536 table_ids: table_ids__.unwrap_or_default(),
16537 })
16538 }
16539 }
16540 deserializer.deserialize_struct("hummock.TruncateTables", FIELDS, GeneratedVisitor)
16541 }
16542}
16543impl serde::Serialize for UnpinVersionBeforeRequest {
16544 #[allow(deprecated)]
16545 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16546 where
16547 S: serde::Serializer,
16548 {
16549 use serde::ser::SerializeStruct;
16550 let mut len = 0;
16551 if self.context_id != 0 {
16552 len += 1;
16553 }
16554 if self.unpin_version_before != 0 {
16555 len += 1;
16556 }
16557 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
16558 if self.context_id != 0 {
16559 struct_ser.serialize_field("contextId", &self.context_id)?;
16560 }
16561 if self.unpin_version_before != 0 {
16562 #[allow(clippy::needless_borrow)]
16563 #[allow(clippy::needless_borrows_for_generic_args)]
16564 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
16565 }
16566 struct_ser.end()
16567 }
16568}
16569impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
16570 #[allow(deprecated)]
16571 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16572 where
16573 D: serde::Deserializer<'de>,
16574 {
16575 const FIELDS: &[&str] = &[
16576 "context_id",
16577 "contextId",
16578 "unpin_version_before",
16579 "unpinVersionBefore",
16580 ];
16581
16582 #[allow(clippy::enum_variant_names)]
16583 enum GeneratedField {
16584 ContextId,
16585 UnpinVersionBefore,
16586 }
16587 impl<'de> serde::Deserialize<'de> for GeneratedField {
16588 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16589 where
16590 D: serde::Deserializer<'de>,
16591 {
16592 struct GeneratedVisitor;
16593
16594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16595 type Value = GeneratedField;
16596
16597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16598 write!(formatter, "expected one of: {:?}", &FIELDS)
16599 }
16600
16601 #[allow(unused_variables)]
16602 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16603 where
16604 E: serde::de::Error,
16605 {
16606 match value {
16607 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
16608 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
16609 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16610 }
16611 }
16612 }
16613 deserializer.deserialize_identifier(GeneratedVisitor)
16614 }
16615 }
16616 struct GeneratedVisitor;
16617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16618 type Value = UnpinVersionBeforeRequest;
16619
16620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16621 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
16622 }
16623
16624 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
16625 where
16626 V: serde::de::MapAccess<'de>,
16627 {
16628 let mut context_id__ = None;
16629 let mut unpin_version_before__ = None;
16630 while let Some(k) = map_.next_key()? {
16631 match k {
16632 GeneratedField::ContextId => {
16633 if context_id__.is_some() {
16634 return Err(serde::de::Error::duplicate_field("contextId"));
16635 }
16636 context_id__ =
16637 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16638 ;
16639 }
16640 GeneratedField::UnpinVersionBefore => {
16641 if unpin_version_before__.is_some() {
16642 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
16643 }
16644 unpin_version_before__ =
16645 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16646 ;
16647 }
16648 }
16649 }
16650 Ok(UnpinVersionBeforeRequest {
16651 context_id: context_id__.unwrap_or_default(),
16652 unpin_version_before: unpin_version_before__.unwrap_or_default(),
16653 })
16654 }
16655 }
16656 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
16657 }
16658}
16659impl serde::Serialize for UnpinVersionBeforeResponse {
16660 #[allow(deprecated)]
16661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16662 where
16663 S: serde::Serializer,
16664 {
16665 use serde::ser::SerializeStruct;
16666 let mut len = 0;
16667 if self.status.is_some() {
16668 len += 1;
16669 }
16670 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
16671 if let Some(v) = self.status.as_ref() {
16672 struct_ser.serialize_field("status", v)?;
16673 }
16674 struct_ser.end()
16675 }
16676}
16677impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
16678 #[allow(deprecated)]
16679 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16680 where
16681 D: serde::Deserializer<'de>,
16682 {
16683 const FIELDS: &[&str] = &[
16684 "status",
16685 ];
16686
16687 #[allow(clippy::enum_variant_names)]
16688 enum GeneratedField {
16689 Status,
16690 }
16691 impl<'de> serde::Deserialize<'de> for GeneratedField {
16692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16693 where
16694 D: serde::Deserializer<'de>,
16695 {
16696 struct GeneratedVisitor;
16697
16698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16699 type Value = GeneratedField;
16700
16701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16702 write!(formatter, "expected one of: {:?}", &FIELDS)
16703 }
16704
16705 #[allow(unused_variables)]
16706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16707 where
16708 E: serde::de::Error,
16709 {
16710 match value {
16711 "status" => Ok(GeneratedField::Status),
16712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16713 }
16714 }
16715 }
16716 deserializer.deserialize_identifier(GeneratedVisitor)
16717 }
16718 }
16719 struct GeneratedVisitor;
16720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16721 type Value = UnpinVersionBeforeResponse;
16722
16723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16724 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
16725 }
16726
16727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
16728 where
16729 V: serde::de::MapAccess<'de>,
16730 {
16731 let mut status__ = None;
16732 while let Some(k) = map_.next_key()? {
16733 match k {
16734 GeneratedField::Status => {
16735 if status__.is_some() {
16736 return Err(serde::de::Error::duplicate_field("status"));
16737 }
16738 status__ = map_.next_value()?;
16739 }
16740 }
16741 }
16742 Ok(UnpinVersionBeforeResponse {
16743 status: status__,
16744 })
16745 }
16746 }
16747 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
16748 }
16749}
16750impl serde::Serialize for UnpinVersionRequest {
16751 #[allow(deprecated)]
16752 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16753 where
16754 S: serde::Serializer,
16755 {
16756 use serde::ser::SerializeStruct;
16757 let mut len = 0;
16758 if self.context_id != 0 {
16759 len += 1;
16760 }
16761 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
16762 if self.context_id != 0 {
16763 struct_ser.serialize_field("contextId", &self.context_id)?;
16764 }
16765 struct_ser.end()
16766 }
16767}
16768impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
16769 #[allow(deprecated)]
16770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16771 where
16772 D: serde::Deserializer<'de>,
16773 {
16774 const FIELDS: &[&str] = &[
16775 "context_id",
16776 "contextId",
16777 ];
16778
16779 #[allow(clippy::enum_variant_names)]
16780 enum GeneratedField {
16781 ContextId,
16782 }
16783 impl<'de> serde::Deserialize<'de> for GeneratedField {
16784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16785 where
16786 D: serde::Deserializer<'de>,
16787 {
16788 struct GeneratedVisitor;
16789
16790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16791 type Value = GeneratedField;
16792
16793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16794 write!(formatter, "expected one of: {:?}", &FIELDS)
16795 }
16796
16797 #[allow(unused_variables)]
16798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16799 where
16800 E: serde::de::Error,
16801 {
16802 match value {
16803 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
16804 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16805 }
16806 }
16807 }
16808 deserializer.deserialize_identifier(GeneratedVisitor)
16809 }
16810 }
16811 struct GeneratedVisitor;
16812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16813 type Value = UnpinVersionRequest;
16814
16815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16816 formatter.write_str("struct hummock.UnpinVersionRequest")
16817 }
16818
16819 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
16820 where
16821 V: serde::de::MapAccess<'de>,
16822 {
16823 let mut context_id__ = None;
16824 while let Some(k) = map_.next_key()? {
16825 match k {
16826 GeneratedField::ContextId => {
16827 if context_id__.is_some() {
16828 return Err(serde::de::Error::duplicate_field("contextId"));
16829 }
16830 context_id__ =
16831 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16832 ;
16833 }
16834 }
16835 }
16836 Ok(UnpinVersionRequest {
16837 context_id: context_id__.unwrap_or_default(),
16838 })
16839 }
16840 }
16841 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
16842 }
16843}
16844impl serde::Serialize for UnpinVersionResponse {
16845 #[allow(deprecated)]
16846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16847 where
16848 S: serde::Serializer,
16849 {
16850 use serde::ser::SerializeStruct;
16851 let mut len = 0;
16852 if self.status.is_some() {
16853 len += 1;
16854 }
16855 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
16856 if let Some(v) = self.status.as_ref() {
16857 struct_ser.serialize_field("status", v)?;
16858 }
16859 struct_ser.end()
16860 }
16861}
16862impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
16863 #[allow(deprecated)]
16864 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16865 where
16866 D: serde::Deserializer<'de>,
16867 {
16868 const FIELDS: &[&str] = &[
16869 "status",
16870 ];
16871
16872 #[allow(clippy::enum_variant_names)]
16873 enum GeneratedField {
16874 Status,
16875 }
16876 impl<'de> serde::Deserialize<'de> for GeneratedField {
16877 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16878 where
16879 D: serde::Deserializer<'de>,
16880 {
16881 struct GeneratedVisitor;
16882
16883 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16884 type Value = GeneratedField;
16885
16886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16887 write!(formatter, "expected one of: {:?}", &FIELDS)
16888 }
16889
16890 #[allow(unused_variables)]
16891 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16892 where
16893 E: serde::de::Error,
16894 {
16895 match value {
16896 "status" => Ok(GeneratedField::Status),
16897 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16898 }
16899 }
16900 }
16901 deserializer.deserialize_identifier(GeneratedVisitor)
16902 }
16903 }
16904 struct GeneratedVisitor;
16905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16906 type Value = UnpinVersionResponse;
16907
16908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16909 formatter.write_str("struct hummock.UnpinVersionResponse")
16910 }
16911
16912 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
16913 where
16914 V: serde::de::MapAccess<'de>,
16915 {
16916 let mut status__ = None;
16917 while let Some(k) = map_.next_key()? {
16918 match k {
16919 GeneratedField::Status => {
16920 if status__.is_some() {
16921 return Err(serde::de::Error::duplicate_field("status"));
16922 }
16923 status__ = map_.next_value()?;
16924 }
16925 }
16926 }
16927 Ok(UnpinVersionResponse {
16928 status: status__,
16929 })
16930 }
16931 }
16932 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
16933 }
16934}
16935impl serde::Serialize for VacuumTask {
16936 #[allow(deprecated)]
16937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16938 where
16939 S: serde::Serializer,
16940 {
16941 use serde::ser::SerializeStruct;
16942 let mut len = 0;
16943 if !self.sstable_object_ids.is_empty() {
16944 len += 1;
16945 }
16946 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
16947 if !self.sstable_object_ids.is_empty() {
16948 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16949 }
16950 struct_ser.end()
16951 }
16952}
16953impl<'de> serde::Deserialize<'de> for VacuumTask {
16954 #[allow(deprecated)]
16955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16956 where
16957 D: serde::Deserializer<'de>,
16958 {
16959 const FIELDS: &[&str] = &[
16960 "sstable_object_ids",
16961 "sstableObjectIds",
16962 ];
16963
16964 #[allow(clippy::enum_variant_names)]
16965 enum GeneratedField {
16966 SstableObjectIds,
16967 }
16968 impl<'de> serde::Deserialize<'de> for GeneratedField {
16969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16970 where
16971 D: serde::Deserializer<'de>,
16972 {
16973 struct GeneratedVisitor;
16974
16975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16976 type Value = GeneratedField;
16977
16978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16979 write!(formatter, "expected one of: {:?}", &FIELDS)
16980 }
16981
16982 #[allow(unused_variables)]
16983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16984 where
16985 E: serde::de::Error,
16986 {
16987 match value {
16988 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
16989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16990 }
16991 }
16992 }
16993 deserializer.deserialize_identifier(GeneratedVisitor)
16994 }
16995 }
16996 struct GeneratedVisitor;
16997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16998 type Value = VacuumTask;
16999
17000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17001 formatter.write_str("struct hummock.VacuumTask")
17002 }
17003
17004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
17005 where
17006 V: serde::de::MapAccess<'de>,
17007 {
17008 let mut sstable_object_ids__ = None;
17009 while let Some(k) = map_.next_key()? {
17010 match k {
17011 GeneratedField::SstableObjectIds => {
17012 if sstable_object_ids__.is_some() {
17013 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
17014 }
17015 sstable_object_ids__ =
17016 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17017 .into_iter().map(|x| x.0).collect())
17018 ;
17019 }
17020 }
17021 }
17022 Ok(VacuumTask {
17023 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
17024 })
17025 }
17026 }
17027 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
17028 }
17029}
17030impl serde::Serialize for ValidationTask {
17031 #[allow(deprecated)]
17032 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17033 where
17034 S: serde::Serializer,
17035 {
17036 use serde::ser::SerializeStruct;
17037 let mut len = 0;
17038 if !self.sst_infos.is_empty() {
17039 len += 1;
17040 }
17041 if !self.sst_id_to_worker_id.is_empty() {
17042 len += 1;
17043 }
17044 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
17045 if !self.sst_infos.is_empty() {
17046 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
17047 }
17048 if !self.sst_id_to_worker_id.is_empty() {
17049 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
17050 }
17051 struct_ser.end()
17052 }
17053}
17054impl<'de> serde::Deserialize<'de> for ValidationTask {
17055 #[allow(deprecated)]
17056 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17057 where
17058 D: serde::Deserializer<'de>,
17059 {
17060 const FIELDS: &[&str] = &[
17061 "sst_infos",
17062 "sstInfos",
17063 "sst_id_to_worker_id",
17064 "sstIdToWorkerId",
17065 ];
17066
17067 #[allow(clippy::enum_variant_names)]
17068 enum GeneratedField {
17069 SstInfos,
17070 SstIdToWorkerId,
17071 }
17072 impl<'de> serde::Deserialize<'de> for GeneratedField {
17073 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17074 where
17075 D: serde::Deserializer<'de>,
17076 {
17077 struct GeneratedVisitor;
17078
17079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17080 type Value = GeneratedField;
17081
17082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17083 write!(formatter, "expected one of: {:?}", &FIELDS)
17084 }
17085
17086 #[allow(unused_variables)]
17087 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17088 where
17089 E: serde::de::Error,
17090 {
17091 match value {
17092 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
17093 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
17094 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17095 }
17096 }
17097 }
17098 deserializer.deserialize_identifier(GeneratedVisitor)
17099 }
17100 }
17101 struct GeneratedVisitor;
17102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17103 type Value = ValidationTask;
17104
17105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17106 formatter.write_str("struct hummock.ValidationTask")
17107 }
17108
17109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
17110 where
17111 V: serde::de::MapAccess<'de>,
17112 {
17113 let mut sst_infos__ = None;
17114 let mut sst_id_to_worker_id__ = None;
17115 while let Some(k) = map_.next_key()? {
17116 match k {
17117 GeneratedField::SstInfos => {
17118 if sst_infos__.is_some() {
17119 return Err(serde::de::Error::duplicate_field("sstInfos"));
17120 }
17121 sst_infos__ = Some(map_.next_value()?);
17122 }
17123 GeneratedField::SstIdToWorkerId => {
17124 if sst_id_to_worker_id__.is_some() {
17125 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
17126 }
17127 sst_id_to_worker_id__ = Some(
17128 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
17129 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
17130 );
17131 }
17132 }
17133 }
17134 Ok(ValidationTask {
17135 sst_infos: sst_infos__.unwrap_or_default(),
17136 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
17137 })
17138 }
17139 }
17140 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
17141 }
17142}
17143impl serde::Serialize for VectorFileInfo {
17144 #[allow(deprecated)]
17145 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17146 where
17147 S: serde::Serializer,
17148 {
17149 use serde::ser::SerializeStruct;
17150 let mut len = 0;
17151 if self.object_id != 0 {
17152 len += 1;
17153 }
17154 if self.file_size != 0 {
17155 len += 1;
17156 }
17157 if self.start_vector_id != 0 {
17158 len += 1;
17159 }
17160 if self.vector_count != 0 {
17161 len += 1;
17162 }
17163 if self.meta_offset != 0 {
17164 len += 1;
17165 }
17166 let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
17167 if self.object_id != 0 {
17168 #[allow(clippy::needless_borrow)]
17169 #[allow(clippy::needless_borrows_for_generic_args)]
17170 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
17171 }
17172 if self.file_size != 0 {
17173 #[allow(clippy::needless_borrow)]
17174 #[allow(clippy::needless_borrows_for_generic_args)]
17175 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
17176 }
17177 if self.start_vector_id != 0 {
17178 #[allow(clippy::needless_borrow)]
17179 #[allow(clippy::needless_borrows_for_generic_args)]
17180 struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
17181 }
17182 if self.vector_count != 0 {
17183 struct_ser.serialize_field("vectorCount", &self.vector_count)?;
17184 }
17185 if self.meta_offset != 0 {
17186 #[allow(clippy::needless_borrow)]
17187 #[allow(clippy::needless_borrows_for_generic_args)]
17188 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
17189 }
17190 struct_ser.end()
17191 }
17192}
17193impl<'de> serde::Deserialize<'de> for VectorFileInfo {
17194 #[allow(deprecated)]
17195 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17196 where
17197 D: serde::Deserializer<'de>,
17198 {
17199 const FIELDS: &[&str] = &[
17200 "object_id",
17201 "objectId",
17202 "file_size",
17203 "fileSize",
17204 "start_vector_id",
17205 "startVectorId",
17206 "vector_count",
17207 "vectorCount",
17208 "meta_offset",
17209 "metaOffset",
17210 ];
17211
17212 #[allow(clippy::enum_variant_names)]
17213 enum GeneratedField {
17214 ObjectId,
17215 FileSize,
17216 StartVectorId,
17217 VectorCount,
17218 MetaOffset,
17219 }
17220 impl<'de> serde::Deserialize<'de> for GeneratedField {
17221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17222 where
17223 D: serde::Deserializer<'de>,
17224 {
17225 struct GeneratedVisitor;
17226
17227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17228 type Value = GeneratedField;
17229
17230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17231 write!(formatter, "expected one of: {:?}", &FIELDS)
17232 }
17233
17234 #[allow(unused_variables)]
17235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17236 where
17237 E: serde::de::Error,
17238 {
17239 match value {
17240 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
17241 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
17242 "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
17243 "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
17244 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
17245 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17246 }
17247 }
17248 }
17249 deserializer.deserialize_identifier(GeneratedVisitor)
17250 }
17251 }
17252 struct GeneratedVisitor;
17253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17254 type Value = VectorFileInfo;
17255
17256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17257 formatter.write_str("struct hummock.VectorFileInfo")
17258 }
17259
17260 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
17261 where
17262 V: serde::de::MapAccess<'de>,
17263 {
17264 let mut object_id__ = None;
17265 let mut file_size__ = None;
17266 let mut start_vector_id__ = None;
17267 let mut vector_count__ = None;
17268 let mut meta_offset__ = None;
17269 while let Some(k) = map_.next_key()? {
17270 match k {
17271 GeneratedField::ObjectId => {
17272 if object_id__.is_some() {
17273 return Err(serde::de::Error::duplicate_field("objectId"));
17274 }
17275 object_id__ =
17276 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17277 ;
17278 }
17279 GeneratedField::FileSize => {
17280 if file_size__.is_some() {
17281 return Err(serde::de::Error::duplicate_field("fileSize"));
17282 }
17283 file_size__ =
17284 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17285 ;
17286 }
17287 GeneratedField::StartVectorId => {
17288 if start_vector_id__.is_some() {
17289 return Err(serde::de::Error::duplicate_field("startVectorId"));
17290 }
17291 start_vector_id__ =
17292 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17293 ;
17294 }
17295 GeneratedField::VectorCount => {
17296 if vector_count__.is_some() {
17297 return Err(serde::de::Error::duplicate_field("vectorCount"));
17298 }
17299 vector_count__ =
17300 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17301 ;
17302 }
17303 GeneratedField::MetaOffset => {
17304 if meta_offset__.is_some() {
17305 return Err(serde::de::Error::duplicate_field("metaOffset"));
17306 }
17307 meta_offset__ =
17308 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17309 ;
17310 }
17311 }
17312 }
17313 Ok(VectorFileInfo {
17314 object_id: object_id__.unwrap_or_default(),
17315 file_size: file_size__.unwrap_or_default(),
17316 start_vector_id: start_vector_id__.unwrap_or_default(),
17317 vector_count: vector_count__.unwrap_or_default(),
17318 meta_offset: meta_offset__.unwrap_or_default(),
17319 })
17320 }
17321 }
17322 deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
17323 }
17324}
17325impl serde::Serialize for VectorIndex {
17326 #[allow(deprecated)]
17327 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17328 where
17329 S: serde::Serializer,
17330 {
17331 use serde::ser::SerializeStruct;
17332 let mut len = 0;
17333 if self.dimension != 0 {
17334 len += 1;
17335 }
17336 if self.distance_type != 0 {
17337 len += 1;
17338 }
17339 if self.variant.is_some() {
17340 len += 1;
17341 }
17342 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
17343 if self.dimension != 0 {
17344 struct_ser.serialize_field("dimension", &self.dimension)?;
17345 }
17346 if self.distance_type != 0 {
17347 let v = super::common::DistanceType::try_from(self.distance_type)
17348 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
17349 struct_ser.serialize_field("distanceType", &v)?;
17350 }
17351 if let Some(v) = self.variant.as_ref() {
17352 match v {
17353 vector_index::Variant::Flat(v) => {
17354 struct_ser.serialize_field("flat", v)?;
17355 }
17356 vector_index::Variant::HnswFlat(v) => {
17357 struct_ser.serialize_field("hnswFlat", v)?;
17358 }
17359 }
17360 }
17361 struct_ser.end()
17362 }
17363}
17364impl<'de> serde::Deserialize<'de> for VectorIndex {
17365 #[allow(deprecated)]
17366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17367 where
17368 D: serde::Deserializer<'de>,
17369 {
17370 const FIELDS: &[&str] = &[
17371 "dimension",
17372 "distance_type",
17373 "distanceType",
17374 "flat",
17375 "hnsw_flat",
17376 "hnswFlat",
17377 ];
17378
17379 #[allow(clippy::enum_variant_names)]
17380 enum GeneratedField {
17381 Dimension,
17382 DistanceType,
17383 Flat,
17384 HnswFlat,
17385 }
17386 impl<'de> serde::Deserialize<'de> for GeneratedField {
17387 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17388 where
17389 D: serde::Deserializer<'de>,
17390 {
17391 struct GeneratedVisitor;
17392
17393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17394 type Value = GeneratedField;
17395
17396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17397 write!(formatter, "expected one of: {:?}", &FIELDS)
17398 }
17399
17400 #[allow(unused_variables)]
17401 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17402 where
17403 E: serde::de::Error,
17404 {
17405 match value {
17406 "dimension" => Ok(GeneratedField::Dimension),
17407 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
17408 "flat" => Ok(GeneratedField::Flat),
17409 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
17410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17411 }
17412 }
17413 }
17414 deserializer.deserialize_identifier(GeneratedVisitor)
17415 }
17416 }
17417 struct GeneratedVisitor;
17418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17419 type Value = VectorIndex;
17420
17421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17422 formatter.write_str("struct hummock.VectorIndex")
17423 }
17424
17425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
17426 where
17427 V: serde::de::MapAccess<'de>,
17428 {
17429 let mut dimension__ = None;
17430 let mut distance_type__ = None;
17431 let mut variant__ = None;
17432 while let Some(k) = map_.next_key()? {
17433 match k {
17434 GeneratedField::Dimension => {
17435 if dimension__.is_some() {
17436 return Err(serde::de::Error::duplicate_field("dimension"));
17437 }
17438 dimension__ =
17439 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17440 ;
17441 }
17442 GeneratedField::DistanceType => {
17443 if distance_type__.is_some() {
17444 return Err(serde::de::Error::duplicate_field("distanceType"));
17445 }
17446 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
17447 }
17448 GeneratedField::Flat => {
17449 if variant__.is_some() {
17450 return Err(serde::de::Error::duplicate_field("flat"));
17451 }
17452 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
17453;
17454 }
17455 GeneratedField::HnswFlat => {
17456 if variant__.is_some() {
17457 return Err(serde::de::Error::duplicate_field("hnswFlat"));
17458 }
17459 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::HnswFlat)
17460;
17461 }
17462 }
17463 }
17464 Ok(VectorIndex {
17465 dimension: dimension__.unwrap_or_default(),
17466 distance_type: distance_type__.unwrap_or_default(),
17467 variant: variant__,
17468 })
17469 }
17470 }
17471 deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
17472 }
17473}
17474impl serde::Serialize for VectorIndexDelta {
17475 #[allow(deprecated)]
17476 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17477 where
17478 S: serde::Serializer,
17479 {
17480 use serde::ser::SerializeStruct;
17481 let mut len = 0;
17482 if self.delta.is_some() {
17483 len += 1;
17484 }
17485 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
17486 if let Some(v) = self.delta.as_ref() {
17487 match v {
17488 vector_index_delta::Delta::Init(v) => {
17489 struct_ser.serialize_field("init", v)?;
17490 }
17491 vector_index_delta::Delta::Adds(v) => {
17492 struct_ser.serialize_field("adds", v)?;
17493 }
17494 }
17495 }
17496 struct_ser.end()
17497 }
17498}
17499impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
17500 #[allow(deprecated)]
17501 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17502 where
17503 D: serde::Deserializer<'de>,
17504 {
17505 const FIELDS: &[&str] = &[
17506 "init",
17507 "adds",
17508 ];
17509
17510 #[allow(clippy::enum_variant_names)]
17511 enum GeneratedField {
17512 Init,
17513 Adds,
17514 }
17515 impl<'de> serde::Deserialize<'de> for GeneratedField {
17516 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17517 where
17518 D: serde::Deserializer<'de>,
17519 {
17520 struct GeneratedVisitor;
17521
17522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17523 type Value = GeneratedField;
17524
17525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17526 write!(formatter, "expected one of: {:?}", &FIELDS)
17527 }
17528
17529 #[allow(unused_variables)]
17530 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17531 where
17532 E: serde::de::Error,
17533 {
17534 match value {
17535 "init" => Ok(GeneratedField::Init),
17536 "adds" => Ok(GeneratedField::Adds),
17537 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17538 }
17539 }
17540 }
17541 deserializer.deserialize_identifier(GeneratedVisitor)
17542 }
17543 }
17544 struct GeneratedVisitor;
17545 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17546 type Value = VectorIndexDelta;
17547
17548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17549 formatter.write_str("struct hummock.VectorIndexDelta")
17550 }
17551
17552 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
17553 where
17554 V: serde::de::MapAccess<'de>,
17555 {
17556 let mut delta__ = None;
17557 while let Some(k) = map_.next_key()? {
17558 match k {
17559 GeneratedField::Init => {
17560 if delta__.is_some() {
17561 return Err(serde::de::Error::duplicate_field("init"));
17562 }
17563 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
17564;
17565 }
17566 GeneratedField::Adds => {
17567 if delta__.is_some() {
17568 return Err(serde::de::Error::duplicate_field("adds"));
17569 }
17570 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
17571;
17572 }
17573 }
17574 }
17575 Ok(VectorIndexDelta {
17576 delta: delta__,
17577 })
17578 }
17579 }
17580 deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
17581 }
17582}
17583impl serde::Serialize for vector_index_delta::VectorIndexAdd {
17584 #[allow(deprecated)]
17585 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17586 where
17587 S: serde::Serializer,
17588 {
17589 use serde::ser::SerializeStruct;
17590 let mut len = 0;
17591 if self.add.is_some() {
17592 len += 1;
17593 }
17594 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
17595 if let Some(v) = self.add.as_ref() {
17596 match v {
17597 vector_index_delta::vector_index_add::Add::Flat(v) => {
17598 struct_ser.serialize_field("flat", v)?;
17599 }
17600 vector_index_delta::vector_index_add::Add::HnswFlat(v) => {
17601 struct_ser.serialize_field("hnswFlat", v)?;
17602 }
17603 }
17604 }
17605 struct_ser.end()
17606 }
17607}
17608impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
17609 #[allow(deprecated)]
17610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17611 where
17612 D: serde::Deserializer<'de>,
17613 {
17614 const FIELDS: &[&str] = &[
17615 "flat",
17616 "hnsw_flat",
17617 "hnswFlat",
17618 ];
17619
17620 #[allow(clippy::enum_variant_names)]
17621 enum GeneratedField {
17622 Flat,
17623 HnswFlat,
17624 }
17625 impl<'de> serde::Deserialize<'de> for GeneratedField {
17626 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17627 where
17628 D: serde::Deserializer<'de>,
17629 {
17630 struct GeneratedVisitor;
17631
17632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17633 type Value = GeneratedField;
17634
17635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17636 write!(formatter, "expected one of: {:?}", &FIELDS)
17637 }
17638
17639 #[allow(unused_variables)]
17640 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17641 where
17642 E: serde::de::Error,
17643 {
17644 match value {
17645 "flat" => Ok(GeneratedField::Flat),
17646 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
17647 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17648 }
17649 }
17650 }
17651 deserializer.deserialize_identifier(GeneratedVisitor)
17652 }
17653 }
17654 struct GeneratedVisitor;
17655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17656 type Value = vector_index_delta::VectorIndexAdd;
17657
17658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17659 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
17660 }
17661
17662 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
17663 where
17664 V: serde::de::MapAccess<'de>,
17665 {
17666 let mut add__ = None;
17667 while let Some(k) = map_.next_key()? {
17668 match k {
17669 GeneratedField::Flat => {
17670 if add__.is_some() {
17671 return Err(serde::de::Error::duplicate_field("flat"));
17672 }
17673 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
17674;
17675 }
17676 GeneratedField::HnswFlat => {
17677 if add__.is_some() {
17678 return Err(serde::de::Error::duplicate_field("hnswFlat"));
17679 }
17680 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::HnswFlat)
17681;
17682 }
17683 }
17684 }
17685 Ok(vector_index_delta::VectorIndexAdd {
17686 add: add__,
17687 })
17688 }
17689 }
17690 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
17691 }
17692}
17693impl serde::Serialize for vector_index_delta::VectorIndexAdds {
17694 #[allow(deprecated)]
17695 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17696 where
17697 S: serde::Serializer,
17698 {
17699 use serde::ser::SerializeStruct;
17700 let mut len = 0;
17701 if !self.adds.is_empty() {
17702 len += 1;
17703 }
17704 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
17705 if !self.adds.is_empty() {
17706 struct_ser.serialize_field("adds", &self.adds)?;
17707 }
17708 struct_ser.end()
17709 }
17710}
17711impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
17712 #[allow(deprecated)]
17713 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17714 where
17715 D: serde::Deserializer<'de>,
17716 {
17717 const FIELDS: &[&str] = &[
17718 "adds",
17719 ];
17720
17721 #[allow(clippy::enum_variant_names)]
17722 enum GeneratedField {
17723 Adds,
17724 }
17725 impl<'de> serde::Deserialize<'de> for GeneratedField {
17726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17727 where
17728 D: serde::Deserializer<'de>,
17729 {
17730 struct GeneratedVisitor;
17731
17732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17733 type Value = GeneratedField;
17734
17735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17736 write!(formatter, "expected one of: {:?}", &FIELDS)
17737 }
17738
17739 #[allow(unused_variables)]
17740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17741 where
17742 E: serde::de::Error,
17743 {
17744 match value {
17745 "adds" => Ok(GeneratedField::Adds),
17746 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17747 }
17748 }
17749 }
17750 deserializer.deserialize_identifier(GeneratedVisitor)
17751 }
17752 }
17753 struct GeneratedVisitor;
17754 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17755 type Value = vector_index_delta::VectorIndexAdds;
17756
17757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17758 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
17759 }
17760
17761 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
17762 where
17763 V: serde::de::MapAccess<'de>,
17764 {
17765 let mut adds__ = None;
17766 while let Some(k) = map_.next_key()? {
17767 match k {
17768 GeneratedField::Adds => {
17769 if adds__.is_some() {
17770 return Err(serde::de::Error::duplicate_field("adds"));
17771 }
17772 adds__ = Some(map_.next_value()?);
17773 }
17774 }
17775 }
17776 Ok(vector_index_delta::VectorIndexAdds {
17777 adds: adds__.unwrap_or_default(),
17778 })
17779 }
17780 }
17781 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
17782 }
17783}
17784impl serde::Serialize for vector_index_delta::VectorIndexInit {
17785 #[allow(deprecated)]
17786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17787 where
17788 S: serde::Serializer,
17789 {
17790 use serde::ser::SerializeStruct;
17791 let mut len = 0;
17792 if self.info.is_some() {
17793 len += 1;
17794 }
17795 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
17796 if let Some(v) = self.info.as_ref() {
17797 struct_ser.serialize_field("info", v)?;
17798 }
17799 struct_ser.end()
17800 }
17801}
17802impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
17803 #[allow(deprecated)]
17804 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17805 where
17806 D: serde::Deserializer<'de>,
17807 {
17808 const FIELDS: &[&str] = &[
17809 "info",
17810 ];
17811
17812 #[allow(clippy::enum_variant_names)]
17813 enum GeneratedField {
17814 Info,
17815 }
17816 impl<'de> serde::Deserialize<'de> for GeneratedField {
17817 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17818 where
17819 D: serde::Deserializer<'de>,
17820 {
17821 struct GeneratedVisitor;
17822
17823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17824 type Value = GeneratedField;
17825
17826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17827 write!(formatter, "expected one of: {:?}", &FIELDS)
17828 }
17829
17830 #[allow(unused_variables)]
17831 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17832 where
17833 E: serde::de::Error,
17834 {
17835 match value {
17836 "info" => Ok(GeneratedField::Info),
17837 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17838 }
17839 }
17840 }
17841 deserializer.deserialize_identifier(GeneratedVisitor)
17842 }
17843 }
17844 struct GeneratedVisitor;
17845 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17846 type Value = vector_index_delta::VectorIndexInit;
17847
17848 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17849 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
17850 }
17851
17852 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
17853 where
17854 V: serde::de::MapAccess<'de>,
17855 {
17856 let mut info__ = None;
17857 while let Some(k) = map_.next_key()? {
17858 match k {
17859 GeneratedField::Info => {
17860 if info__.is_some() {
17861 return Err(serde::de::Error::duplicate_field("info"));
17862 }
17863 info__ = map_.next_value()?;
17864 }
17865 }
17866 }
17867 Ok(vector_index_delta::VectorIndexInit {
17868 info: info__,
17869 })
17870 }
17871 }
17872 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
17873 }
17874}
17875impl serde::Serialize for VectorIndexObject {
17876 #[allow(deprecated)]
17877 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17878 where
17879 S: serde::Serializer,
17880 {
17881 use serde::ser::SerializeStruct;
17882 let mut len = 0;
17883 if self.id != 0 {
17884 len += 1;
17885 }
17886 if self.object_type != 0 {
17887 len += 1;
17888 }
17889 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
17890 if self.id != 0 {
17891 #[allow(clippy::needless_borrow)]
17892 #[allow(clippy::needless_borrows_for_generic_args)]
17893 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
17894 }
17895 if self.object_type != 0 {
17896 let v = VectorIndexObjectType::try_from(self.object_type)
17897 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
17898 struct_ser.serialize_field("objectType", &v)?;
17899 }
17900 struct_ser.end()
17901 }
17902}
17903impl<'de> serde::Deserialize<'de> for VectorIndexObject {
17904 #[allow(deprecated)]
17905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17906 where
17907 D: serde::Deserializer<'de>,
17908 {
17909 const FIELDS: &[&str] = &[
17910 "id",
17911 "object_type",
17912 "objectType",
17913 ];
17914
17915 #[allow(clippy::enum_variant_names)]
17916 enum GeneratedField {
17917 Id,
17918 ObjectType,
17919 }
17920 impl<'de> serde::Deserialize<'de> for GeneratedField {
17921 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17922 where
17923 D: serde::Deserializer<'de>,
17924 {
17925 struct GeneratedVisitor;
17926
17927 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17928 type Value = GeneratedField;
17929
17930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17931 write!(formatter, "expected one of: {:?}", &FIELDS)
17932 }
17933
17934 #[allow(unused_variables)]
17935 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17936 where
17937 E: serde::de::Error,
17938 {
17939 match value {
17940 "id" => Ok(GeneratedField::Id),
17941 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
17942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17943 }
17944 }
17945 }
17946 deserializer.deserialize_identifier(GeneratedVisitor)
17947 }
17948 }
17949 struct GeneratedVisitor;
17950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17951 type Value = VectorIndexObject;
17952
17953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17954 formatter.write_str("struct hummock.VectorIndexObject")
17955 }
17956
17957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
17958 where
17959 V: serde::de::MapAccess<'de>,
17960 {
17961 let mut id__ = None;
17962 let mut object_type__ = None;
17963 while let Some(k) = map_.next_key()? {
17964 match k {
17965 GeneratedField::Id => {
17966 if id__.is_some() {
17967 return Err(serde::de::Error::duplicate_field("id"));
17968 }
17969 id__ =
17970 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17971 ;
17972 }
17973 GeneratedField::ObjectType => {
17974 if object_type__.is_some() {
17975 return Err(serde::de::Error::duplicate_field("objectType"));
17976 }
17977 object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
17978 }
17979 }
17980 }
17981 Ok(VectorIndexObject {
17982 id: id__.unwrap_or_default(),
17983 object_type: object_type__.unwrap_or_default(),
17984 })
17985 }
17986 }
17987 deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
17988 }
17989}
17990impl serde::Serialize for VectorIndexObjectType {
17991 #[allow(deprecated)]
17992 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17993 where
17994 S: serde::Serializer,
17995 {
17996 let variant = match self {
17997 Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17998 Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
17999 Self::VectorIndexObjectHnswGraph => "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
18000 };
18001 serializer.serialize_str(variant)
18002 }
18003}
18004impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
18005 #[allow(deprecated)]
18006 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18007 where
18008 D: serde::Deserializer<'de>,
18009 {
18010 const FIELDS: &[&str] = &[
18011 "VECTOR_INDEX_OBJECT_UNSPECIFIED",
18012 "VECTOR_INDEX_OBJECT_VECTOR",
18013 "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
18014 ];
18015
18016 struct GeneratedVisitor;
18017
18018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18019 type Value = VectorIndexObjectType;
18020
18021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18022 write!(formatter, "expected one of: {:?}", &FIELDS)
18023 }
18024
18025 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18026 where
18027 E: serde::de::Error,
18028 {
18029 i32::try_from(v)
18030 .ok()
18031 .and_then(|x| x.try_into().ok())
18032 .ok_or_else(|| {
18033 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18034 })
18035 }
18036
18037 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18038 where
18039 E: serde::de::Error,
18040 {
18041 i32::try_from(v)
18042 .ok()
18043 .and_then(|x| x.try_into().ok())
18044 .ok_or_else(|| {
18045 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18046 })
18047 }
18048
18049 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18050 where
18051 E: serde::de::Error,
18052 {
18053 match value {
18054 "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
18055 "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
18056 "VECTOR_INDEX_OBJECT_HNSW_GRAPH" => Ok(VectorIndexObjectType::VectorIndexObjectHnswGraph),
18057 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18058 }
18059 }
18060 }
18061 deserializer.deserialize_any(GeneratedVisitor)
18062 }
18063}
18064impl serde::Serialize for VersionUpdatePayload {
18065 #[allow(deprecated)]
18066 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18067 where
18068 S: serde::Serializer,
18069 {
18070 use serde::ser::SerializeStruct;
18071 let mut len = 0;
18072 if self.payload.is_some() {
18073 len += 1;
18074 }
18075 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
18076 if let Some(v) = self.payload.as_ref() {
18077 match v {
18078 version_update_payload::Payload::VersionDeltas(v) => {
18079 struct_ser.serialize_field("versionDeltas", v)?;
18080 }
18081 version_update_payload::Payload::PinnedVersion(v) => {
18082 struct_ser.serialize_field("pinnedVersion", v)?;
18083 }
18084 }
18085 }
18086 struct_ser.end()
18087 }
18088}
18089impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
18090 #[allow(deprecated)]
18091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18092 where
18093 D: serde::Deserializer<'de>,
18094 {
18095 const FIELDS: &[&str] = &[
18096 "version_deltas",
18097 "versionDeltas",
18098 "pinned_version",
18099 "pinnedVersion",
18100 ];
18101
18102 #[allow(clippy::enum_variant_names)]
18103 enum GeneratedField {
18104 VersionDeltas,
18105 PinnedVersion,
18106 }
18107 impl<'de> serde::Deserialize<'de> for GeneratedField {
18108 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18109 where
18110 D: serde::Deserializer<'de>,
18111 {
18112 struct GeneratedVisitor;
18113
18114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18115 type Value = GeneratedField;
18116
18117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18118 write!(formatter, "expected one of: {:?}", &FIELDS)
18119 }
18120
18121 #[allow(unused_variables)]
18122 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18123 where
18124 E: serde::de::Error,
18125 {
18126 match value {
18127 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
18128 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
18129 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18130 }
18131 }
18132 }
18133 deserializer.deserialize_identifier(GeneratedVisitor)
18134 }
18135 }
18136 struct GeneratedVisitor;
18137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18138 type Value = VersionUpdatePayload;
18139
18140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18141 formatter.write_str("struct hummock.VersionUpdatePayload")
18142 }
18143
18144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
18145 where
18146 V: serde::de::MapAccess<'de>,
18147 {
18148 let mut payload__ = None;
18149 while let Some(k) = map_.next_key()? {
18150 match k {
18151 GeneratedField::VersionDeltas => {
18152 if payload__.is_some() {
18153 return Err(serde::de::Error::duplicate_field("versionDeltas"));
18154 }
18155 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
18156;
18157 }
18158 GeneratedField::PinnedVersion => {
18159 if payload__.is_some() {
18160 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
18161 }
18162 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
18163;
18164 }
18165 }
18166 }
18167 Ok(VersionUpdatePayload {
18168 payload: payload__,
18169 })
18170 }
18171 }
18172 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
18173 }
18174}
18175impl serde::Serialize for VnodeWatermark {
18176 #[allow(deprecated)]
18177 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18178 where
18179 S: serde::Serializer,
18180 {
18181 use serde::ser::SerializeStruct;
18182 let mut len = 0;
18183 if !self.watermark.is_empty() {
18184 len += 1;
18185 }
18186 if self.vnode_bitmap.is_some() {
18187 len += 1;
18188 }
18189 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
18190 if !self.watermark.is_empty() {
18191 #[allow(clippy::needless_borrow)]
18192 #[allow(clippy::needless_borrows_for_generic_args)]
18193 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
18194 }
18195 if let Some(v) = self.vnode_bitmap.as_ref() {
18196 struct_ser.serialize_field("vnodeBitmap", v)?;
18197 }
18198 struct_ser.end()
18199 }
18200}
18201impl<'de> serde::Deserialize<'de> for VnodeWatermark {
18202 #[allow(deprecated)]
18203 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18204 where
18205 D: serde::Deserializer<'de>,
18206 {
18207 const FIELDS: &[&str] = &[
18208 "watermark",
18209 "vnode_bitmap",
18210 "vnodeBitmap",
18211 ];
18212
18213 #[allow(clippy::enum_variant_names)]
18214 enum GeneratedField {
18215 Watermark,
18216 VnodeBitmap,
18217 }
18218 impl<'de> serde::Deserialize<'de> for GeneratedField {
18219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18220 where
18221 D: serde::Deserializer<'de>,
18222 {
18223 struct GeneratedVisitor;
18224
18225 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18226 type Value = GeneratedField;
18227
18228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18229 write!(formatter, "expected one of: {:?}", &FIELDS)
18230 }
18231
18232 #[allow(unused_variables)]
18233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18234 where
18235 E: serde::de::Error,
18236 {
18237 match value {
18238 "watermark" => Ok(GeneratedField::Watermark),
18239 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
18240 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18241 }
18242 }
18243 }
18244 deserializer.deserialize_identifier(GeneratedVisitor)
18245 }
18246 }
18247 struct GeneratedVisitor;
18248 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18249 type Value = VnodeWatermark;
18250
18251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18252 formatter.write_str("struct hummock.VnodeWatermark")
18253 }
18254
18255 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
18256 where
18257 V: serde::de::MapAccess<'de>,
18258 {
18259 let mut watermark__ = None;
18260 let mut vnode_bitmap__ = None;
18261 while let Some(k) = map_.next_key()? {
18262 match k {
18263 GeneratedField::Watermark => {
18264 if watermark__.is_some() {
18265 return Err(serde::de::Error::duplicate_field("watermark"));
18266 }
18267 watermark__ =
18268 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
18269 ;
18270 }
18271 GeneratedField::VnodeBitmap => {
18272 if vnode_bitmap__.is_some() {
18273 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
18274 }
18275 vnode_bitmap__ = map_.next_value()?;
18276 }
18277 }
18278 }
18279 Ok(VnodeWatermark {
18280 watermark: watermark__.unwrap_or_default(),
18281 vnode_bitmap: vnode_bitmap__,
18282 })
18283 }
18284 }
18285 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
18286 }
18287}
18288impl serde::Serialize for WriteLimits {
18289 #[allow(deprecated)]
18290 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18291 where
18292 S: serde::Serializer,
18293 {
18294 use serde::ser::SerializeStruct;
18295 let mut len = 0;
18296 if !self.write_limits.is_empty() {
18297 len += 1;
18298 }
18299 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
18300 if !self.write_limits.is_empty() {
18301 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
18302 }
18303 struct_ser.end()
18304 }
18305}
18306impl<'de> serde::Deserialize<'de> for WriteLimits {
18307 #[allow(deprecated)]
18308 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18309 where
18310 D: serde::Deserializer<'de>,
18311 {
18312 const FIELDS: &[&str] = &[
18313 "write_limits",
18314 "writeLimits",
18315 ];
18316
18317 #[allow(clippy::enum_variant_names)]
18318 enum GeneratedField {
18319 WriteLimits,
18320 }
18321 impl<'de> serde::Deserialize<'de> for GeneratedField {
18322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18323 where
18324 D: serde::Deserializer<'de>,
18325 {
18326 struct GeneratedVisitor;
18327
18328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18329 type Value = GeneratedField;
18330
18331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18332 write!(formatter, "expected one of: {:?}", &FIELDS)
18333 }
18334
18335 #[allow(unused_variables)]
18336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18337 where
18338 E: serde::de::Error,
18339 {
18340 match value {
18341 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
18342 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18343 }
18344 }
18345 }
18346 deserializer.deserialize_identifier(GeneratedVisitor)
18347 }
18348 }
18349 struct GeneratedVisitor;
18350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18351 type Value = WriteLimits;
18352
18353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18354 formatter.write_str("struct hummock.WriteLimits")
18355 }
18356
18357 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
18358 where
18359 V: serde::de::MapAccess<'de>,
18360 {
18361 let mut write_limits__ = None;
18362 while let Some(k) = map_.next_key()? {
18363 match k {
18364 GeneratedField::WriteLimits => {
18365 if write_limits__.is_some() {
18366 return Err(serde::de::Error::duplicate_field("writeLimits"));
18367 }
18368 write_limits__ = Some(
18369 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
18370 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18371 );
18372 }
18373 }
18374 }
18375 Ok(WriteLimits {
18376 write_limits: write_limits__.unwrap_or_default(),
18377 })
18378 }
18379 }
18380 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
18381 }
18382}
18383impl serde::Serialize for write_limits::WriteLimit {
18384 #[allow(deprecated)]
18385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18386 where
18387 S: serde::Serializer,
18388 {
18389 use serde::ser::SerializeStruct;
18390 let mut len = 0;
18391 if !self.table_ids.is_empty() {
18392 len += 1;
18393 }
18394 if !self.reason.is_empty() {
18395 len += 1;
18396 }
18397 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
18398 if !self.table_ids.is_empty() {
18399 struct_ser.serialize_field("tableIds", &self.table_ids)?;
18400 }
18401 if !self.reason.is_empty() {
18402 struct_ser.serialize_field("reason", &self.reason)?;
18403 }
18404 struct_ser.end()
18405 }
18406}
18407impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
18408 #[allow(deprecated)]
18409 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18410 where
18411 D: serde::Deserializer<'de>,
18412 {
18413 const FIELDS: &[&str] = &[
18414 "table_ids",
18415 "tableIds",
18416 "reason",
18417 ];
18418
18419 #[allow(clippy::enum_variant_names)]
18420 enum GeneratedField {
18421 TableIds,
18422 Reason,
18423 }
18424 impl<'de> serde::Deserialize<'de> for GeneratedField {
18425 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18426 where
18427 D: serde::Deserializer<'de>,
18428 {
18429 struct GeneratedVisitor;
18430
18431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18432 type Value = GeneratedField;
18433
18434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18435 write!(formatter, "expected one of: {:?}", &FIELDS)
18436 }
18437
18438 #[allow(unused_variables)]
18439 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18440 where
18441 E: serde::de::Error,
18442 {
18443 match value {
18444 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
18445 "reason" => Ok(GeneratedField::Reason),
18446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18447 }
18448 }
18449 }
18450 deserializer.deserialize_identifier(GeneratedVisitor)
18451 }
18452 }
18453 struct GeneratedVisitor;
18454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18455 type Value = write_limits::WriteLimit;
18456
18457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18458 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
18459 }
18460
18461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
18462 where
18463 V: serde::de::MapAccess<'de>,
18464 {
18465 let mut table_ids__ = None;
18466 let mut reason__ = None;
18467 while let Some(k) = map_.next_key()? {
18468 match k {
18469 GeneratedField::TableIds => {
18470 if table_ids__.is_some() {
18471 return Err(serde::de::Error::duplicate_field("tableIds"));
18472 }
18473 table_ids__ =
18474 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18475 .into_iter().map(|x| x.0).collect())
18476 ;
18477 }
18478 GeneratedField::Reason => {
18479 if reason__.is_some() {
18480 return Err(serde::de::Error::duplicate_field("reason"));
18481 }
18482 reason__ = Some(map_.next_value()?);
18483 }
18484 }
18485 }
18486 Ok(write_limits::WriteLimit {
18487 table_ids: table_ids__.unwrap_or_default(),
18488 reason: reason__.unwrap_or_default(),
18489 })
18490 }
18491 }
18492 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
18493 }
18494}