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 let mut struct_ser = serializer.serialize_struct("hummock.CompactTask", len)?;
734 if !self.input_ssts.is_empty() {
735 struct_ser.serialize_field("inputSsts", &self.input_ssts)?;
736 }
737 if !self.splits.is_empty() {
738 struct_ser.serialize_field("splits", &self.splits)?;
739 }
740 if !self.sorted_output_ssts.is_empty() {
741 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
742 }
743 if self.task_id != 0 {
744 #[allow(clippy::needless_borrow)]
745 #[allow(clippy::needless_borrows_for_generic_args)]
746 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
747 }
748 if self.target_level != 0 {
749 struct_ser.serialize_field("targetLevel", &self.target_level)?;
750 }
751 if self.gc_delete_keys {
752 struct_ser.serialize_field("gcDeleteKeys", &self.gc_delete_keys)?;
753 }
754 if self.base_level != 0 {
755 struct_ser.serialize_field("baseLevel", &self.base_level)?;
756 }
757 if self.task_status != 0 {
758 let v = compact_task::TaskStatus::try_from(self.task_status)
759 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
760 struct_ser.serialize_field("taskStatus", &v)?;
761 }
762 if self.compaction_group_id != 0 {
763 #[allow(clippy::needless_borrow)]
764 #[allow(clippy::needless_borrows_for_generic_args)]
765 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
766 }
767 if !self.existing_table_ids.is_empty() {
768 struct_ser.serialize_field("existingTableIds", &self.existing_table_ids)?;
769 }
770 if self.compression_algorithm != 0 {
771 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
772 }
773 if self.target_file_size != 0 {
774 #[allow(clippy::needless_borrow)]
775 #[allow(clippy::needless_borrows_for_generic_args)]
776 struct_ser.serialize_field("targetFileSize", ToString::to_string(&self.target_file_size).as_str())?;
777 }
778 if self.compaction_filter_mask != 0 {
779 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
780 }
781 if !self.table_options.is_empty() {
782 struct_ser.serialize_field("tableOptions", &self.table_options)?;
783 }
784 if self.current_epoch_time != 0 {
785 #[allow(clippy::needless_borrow)]
786 #[allow(clippy::needless_borrows_for_generic_args)]
787 struct_ser.serialize_field("currentEpochTime", ToString::to_string(&self.current_epoch_time).as_str())?;
788 }
789 if self.target_sub_level_id != 0 {
790 #[allow(clippy::needless_borrow)]
791 #[allow(clippy::needless_borrows_for_generic_args)]
792 struct_ser.serialize_field("targetSubLevelId", ToString::to_string(&self.target_sub_level_id).as_str())?;
793 }
794 if self.task_type != 0 {
795 let v = compact_task::TaskType::try_from(self.task_type)
796 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_type)))?;
797 struct_ser.serialize_field("taskType", &v)?;
798 }
799 if self.split_by_state_table {
800 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
801 }
802 if self.split_weight_by_vnode != 0 {
803 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
804 }
805 if !self.table_vnode_partition.is_empty() {
806 struct_ser.serialize_field("tableVnodePartition", &self.table_vnode_partition)?;
807 }
808 if !self.table_watermarks.is_empty() {
809 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
810 }
811 if !self.table_schemas.is_empty() {
812 struct_ser.serialize_field("tableSchemas", &self.table_schemas)?;
813 }
814 if self.max_sub_compaction != 0 {
815 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
816 }
817 if self.compaction_group_version_id != 0 {
818 #[allow(clippy::needless_borrow)]
819 #[allow(clippy::needless_borrows_for_generic_args)]
820 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
821 }
822 struct_ser.end()
823 }
824}
825impl<'de> serde::Deserialize<'de> for CompactTask {
826 #[allow(deprecated)]
827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
828 where
829 D: serde::Deserializer<'de>,
830 {
831 const FIELDS: &[&str] = &[
832 "input_ssts",
833 "inputSsts",
834 "splits",
835 "sorted_output_ssts",
836 "sortedOutputSsts",
837 "task_id",
838 "taskId",
839 "target_level",
840 "targetLevel",
841 "gc_delete_keys",
842 "gcDeleteKeys",
843 "base_level",
844 "baseLevel",
845 "task_status",
846 "taskStatus",
847 "compaction_group_id",
848 "compactionGroupId",
849 "existing_table_ids",
850 "existingTableIds",
851 "compression_algorithm",
852 "compressionAlgorithm",
853 "target_file_size",
854 "targetFileSize",
855 "compaction_filter_mask",
856 "compactionFilterMask",
857 "table_options",
858 "tableOptions",
859 "current_epoch_time",
860 "currentEpochTime",
861 "target_sub_level_id",
862 "targetSubLevelId",
863 "task_type",
864 "taskType",
865 "split_by_state_table",
866 "splitByStateTable",
867 "split_weight_by_vnode",
868 "splitWeightByVnode",
869 "table_vnode_partition",
870 "tableVnodePartition",
871 "table_watermarks",
872 "tableWatermarks",
873 "table_schemas",
874 "tableSchemas",
875 "max_sub_compaction",
876 "maxSubCompaction",
877 "compaction_group_version_id",
878 "compactionGroupVersionId",
879 ];
880
881 #[allow(clippy::enum_variant_names)]
882 enum GeneratedField {
883 InputSsts,
884 Splits,
885 SortedOutputSsts,
886 TaskId,
887 TargetLevel,
888 GcDeleteKeys,
889 BaseLevel,
890 TaskStatus,
891 CompactionGroupId,
892 ExistingTableIds,
893 CompressionAlgorithm,
894 TargetFileSize,
895 CompactionFilterMask,
896 TableOptions,
897 CurrentEpochTime,
898 TargetSubLevelId,
899 TaskType,
900 SplitByStateTable,
901 SplitWeightByVnode,
902 TableVnodePartition,
903 TableWatermarks,
904 TableSchemas,
905 MaxSubCompaction,
906 CompactionGroupVersionId,
907 }
908 impl<'de> serde::Deserialize<'de> for GeneratedField {
909 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
910 where
911 D: serde::Deserializer<'de>,
912 {
913 struct GeneratedVisitor;
914
915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
916 type Value = GeneratedField;
917
918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
919 write!(formatter, "expected one of: {:?}", &FIELDS)
920 }
921
922 #[allow(unused_variables)]
923 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
924 where
925 E: serde::de::Error,
926 {
927 match value {
928 "inputSsts" | "input_ssts" => Ok(GeneratedField::InputSsts),
929 "splits" => Ok(GeneratedField::Splits),
930 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
931 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
932 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
933 "gcDeleteKeys" | "gc_delete_keys" => Ok(GeneratedField::GcDeleteKeys),
934 "baseLevel" | "base_level" => Ok(GeneratedField::BaseLevel),
935 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
936 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
937 "existingTableIds" | "existing_table_ids" => Ok(GeneratedField::ExistingTableIds),
938 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
939 "targetFileSize" | "target_file_size" => Ok(GeneratedField::TargetFileSize),
940 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
941 "tableOptions" | "table_options" => Ok(GeneratedField::TableOptions),
942 "currentEpochTime" | "current_epoch_time" => Ok(GeneratedField::CurrentEpochTime),
943 "targetSubLevelId" | "target_sub_level_id" => Ok(GeneratedField::TargetSubLevelId),
944 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
945 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
946 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
947 "tableVnodePartition" | "table_vnode_partition" => Ok(GeneratedField::TableVnodePartition),
948 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
949 "tableSchemas" | "table_schemas" => Ok(GeneratedField::TableSchemas),
950 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
951 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
952 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
953 }
954 }
955 }
956 deserializer.deserialize_identifier(GeneratedVisitor)
957 }
958 }
959 struct GeneratedVisitor;
960 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
961 type Value = CompactTask;
962
963 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
964 formatter.write_str("struct hummock.CompactTask")
965 }
966
967 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTask, V::Error>
968 where
969 V: serde::de::MapAccess<'de>,
970 {
971 let mut input_ssts__ = None;
972 let mut splits__ = None;
973 let mut sorted_output_ssts__ = None;
974 let mut task_id__ = None;
975 let mut target_level__ = None;
976 let mut gc_delete_keys__ = None;
977 let mut base_level__ = None;
978 let mut task_status__ = None;
979 let mut compaction_group_id__ = None;
980 let mut existing_table_ids__ = None;
981 let mut compression_algorithm__ = None;
982 let mut target_file_size__ = None;
983 let mut compaction_filter_mask__ = None;
984 let mut table_options__ = None;
985 let mut current_epoch_time__ = None;
986 let mut target_sub_level_id__ = None;
987 let mut task_type__ = None;
988 let mut split_by_state_table__ = None;
989 let mut split_weight_by_vnode__ = None;
990 let mut table_vnode_partition__ = None;
991 let mut table_watermarks__ = None;
992 let mut table_schemas__ = None;
993 let mut max_sub_compaction__ = None;
994 let mut compaction_group_version_id__ = None;
995 while let Some(k) = map_.next_key()? {
996 match k {
997 GeneratedField::InputSsts => {
998 if input_ssts__.is_some() {
999 return Err(serde::de::Error::duplicate_field("inputSsts"));
1000 }
1001 input_ssts__ = Some(map_.next_value()?);
1002 }
1003 GeneratedField::Splits => {
1004 if splits__.is_some() {
1005 return Err(serde::de::Error::duplicate_field("splits"));
1006 }
1007 splits__ = Some(map_.next_value()?);
1008 }
1009 GeneratedField::SortedOutputSsts => {
1010 if sorted_output_ssts__.is_some() {
1011 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
1012 }
1013 sorted_output_ssts__ = Some(map_.next_value()?);
1014 }
1015 GeneratedField::TaskId => {
1016 if task_id__.is_some() {
1017 return Err(serde::de::Error::duplicate_field("taskId"));
1018 }
1019 task_id__ =
1020 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1021 ;
1022 }
1023 GeneratedField::TargetLevel => {
1024 if target_level__.is_some() {
1025 return Err(serde::de::Error::duplicate_field("targetLevel"));
1026 }
1027 target_level__ =
1028 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1029 ;
1030 }
1031 GeneratedField::GcDeleteKeys => {
1032 if gc_delete_keys__.is_some() {
1033 return Err(serde::de::Error::duplicate_field("gcDeleteKeys"));
1034 }
1035 gc_delete_keys__ = Some(map_.next_value()?);
1036 }
1037 GeneratedField::BaseLevel => {
1038 if base_level__.is_some() {
1039 return Err(serde::de::Error::duplicate_field("baseLevel"));
1040 }
1041 base_level__ =
1042 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1043 ;
1044 }
1045 GeneratedField::TaskStatus => {
1046 if task_status__.is_some() {
1047 return Err(serde::de::Error::duplicate_field("taskStatus"));
1048 }
1049 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
1050 }
1051 GeneratedField::CompactionGroupId => {
1052 if compaction_group_id__.is_some() {
1053 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1054 }
1055 compaction_group_id__ =
1056 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1057 ;
1058 }
1059 GeneratedField::ExistingTableIds => {
1060 if existing_table_ids__.is_some() {
1061 return Err(serde::de::Error::duplicate_field("existingTableIds"));
1062 }
1063 existing_table_ids__ =
1064 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1065 .into_iter().map(|x| x.0).collect())
1066 ;
1067 }
1068 GeneratedField::CompressionAlgorithm => {
1069 if compression_algorithm__.is_some() {
1070 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
1071 }
1072 compression_algorithm__ =
1073 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1074 ;
1075 }
1076 GeneratedField::TargetFileSize => {
1077 if target_file_size__.is_some() {
1078 return Err(serde::de::Error::duplicate_field("targetFileSize"));
1079 }
1080 target_file_size__ =
1081 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1082 ;
1083 }
1084 GeneratedField::CompactionFilterMask => {
1085 if compaction_filter_mask__.is_some() {
1086 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
1087 }
1088 compaction_filter_mask__ =
1089 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1090 ;
1091 }
1092 GeneratedField::TableOptions => {
1093 if table_options__.is_some() {
1094 return Err(serde::de::Error::duplicate_field("tableOptions"));
1095 }
1096 table_options__ = Some(
1097 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1098 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1099 );
1100 }
1101 GeneratedField::CurrentEpochTime => {
1102 if current_epoch_time__.is_some() {
1103 return Err(serde::de::Error::duplicate_field("currentEpochTime"));
1104 }
1105 current_epoch_time__ =
1106 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1107 ;
1108 }
1109 GeneratedField::TargetSubLevelId => {
1110 if target_sub_level_id__.is_some() {
1111 return Err(serde::de::Error::duplicate_field("targetSubLevelId"));
1112 }
1113 target_sub_level_id__ =
1114 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1115 ;
1116 }
1117 GeneratedField::TaskType => {
1118 if task_type__.is_some() {
1119 return Err(serde::de::Error::duplicate_field("taskType"));
1120 }
1121 task_type__ = Some(map_.next_value::<compact_task::TaskType>()? as i32);
1122 }
1123 GeneratedField::SplitByStateTable => {
1124 if split_by_state_table__.is_some() {
1125 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
1126 }
1127 split_by_state_table__ = Some(map_.next_value()?);
1128 }
1129 GeneratedField::SplitWeightByVnode => {
1130 if split_weight_by_vnode__.is_some() {
1131 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
1132 }
1133 split_weight_by_vnode__ =
1134 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1135 ;
1136 }
1137 GeneratedField::TableVnodePartition => {
1138 if table_vnode_partition__.is_some() {
1139 return Err(serde::de::Error::duplicate_field("tableVnodePartition"));
1140 }
1141 table_vnode_partition__ = Some(
1142 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
1143 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
1144 );
1145 }
1146 GeneratedField::TableWatermarks => {
1147 if table_watermarks__.is_some() {
1148 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
1149 }
1150 table_watermarks__ = Some(
1151 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1152 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1153 );
1154 }
1155 GeneratedField::TableSchemas => {
1156 if table_schemas__.is_some() {
1157 return Err(serde::de::Error::duplicate_field("tableSchemas"));
1158 }
1159 table_schemas__ = Some(
1160 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1161 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1162 );
1163 }
1164 GeneratedField::MaxSubCompaction => {
1165 if max_sub_compaction__.is_some() {
1166 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
1167 }
1168 max_sub_compaction__ =
1169 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1170 ;
1171 }
1172 GeneratedField::CompactionGroupVersionId => {
1173 if compaction_group_version_id__.is_some() {
1174 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
1175 }
1176 compaction_group_version_id__ =
1177 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1178 ;
1179 }
1180 }
1181 }
1182 Ok(CompactTask {
1183 input_ssts: input_ssts__.unwrap_or_default(),
1184 splits: splits__.unwrap_or_default(),
1185 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
1186 task_id: task_id__.unwrap_or_default(),
1187 target_level: target_level__.unwrap_or_default(),
1188 gc_delete_keys: gc_delete_keys__.unwrap_or_default(),
1189 base_level: base_level__.unwrap_or_default(),
1190 task_status: task_status__.unwrap_or_default(),
1191 compaction_group_id: compaction_group_id__.unwrap_or_default(),
1192 existing_table_ids: existing_table_ids__.unwrap_or_default(),
1193 compression_algorithm: compression_algorithm__.unwrap_or_default(),
1194 target_file_size: target_file_size__.unwrap_or_default(),
1195 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
1196 table_options: table_options__.unwrap_or_default(),
1197 current_epoch_time: current_epoch_time__.unwrap_or_default(),
1198 target_sub_level_id: target_sub_level_id__.unwrap_or_default(),
1199 task_type: task_type__.unwrap_or_default(),
1200 split_by_state_table: split_by_state_table__.unwrap_or_default(),
1201 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
1202 table_vnode_partition: table_vnode_partition__.unwrap_or_default(),
1203 table_watermarks: table_watermarks__.unwrap_or_default(),
1204 table_schemas: table_schemas__.unwrap_or_default(),
1205 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
1206 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
1207 })
1208 }
1209 }
1210 deserializer.deserialize_struct("hummock.CompactTask", FIELDS, GeneratedVisitor)
1211 }
1212}
1213impl serde::Serialize for compact_task::TaskStatus {
1214 #[allow(deprecated)]
1215 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1216 where
1217 S: serde::Serializer,
1218 {
1219 let variant = match self {
1220 Self::Unspecified => "UNSPECIFIED",
1221 Self::Pending => "PENDING",
1222 Self::Success => "SUCCESS",
1223 Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
1224 Self::NoAvailMemoryResourceCanceled => "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1225 Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
1226 Self::SendFailCanceled => "SEND_FAIL_CANCELED",
1227 Self::ManualCanceled => "MANUAL_CANCELED",
1228 Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
1229 Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
1230 Self::ExecuteFailed => "EXECUTE_FAILED",
1231 Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
1232 Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
1233 Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
1234 Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
1235 Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
1236 Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
1237 Self::ServerlessTableNotFoundCanceled => "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1238 };
1239 serializer.serialize_str(variant)
1240 }
1241}
1242impl<'de> serde::Deserialize<'de> for compact_task::TaskStatus {
1243 #[allow(deprecated)]
1244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1245 where
1246 D: serde::Deserializer<'de>,
1247 {
1248 const FIELDS: &[&str] = &[
1249 "UNSPECIFIED",
1250 "PENDING",
1251 "SUCCESS",
1252 "HEARTBEAT_CANCELED",
1253 "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1254 "ASSIGN_FAIL_CANCELED",
1255 "SEND_FAIL_CANCELED",
1256 "MANUAL_CANCELED",
1257 "INVALID_GROUP_CANCELED",
1258 "INPUT_OUTDATED_CANCELED",
1259 "EXECUTE_FAILED",
1260 "JOIN_HANDLE_FAILED",
1261 "TRACK_SST_OBJECT_ID_FAILED",
1262 "NO_AVAIL_CPU_RESOURCE_CANCELED",
1263 "HEARTBEAT_PROGRESS_CANCELED",
1264 "RETENTION_TIME_REJECTED",
1265 "SERVERLESS_SEND_FAIL_CANCELED",
1266 "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1267 ];
1268
1269 struct GeneratedVisitor;
1270
1271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1272 type Value = compact_task::TaskStatus;
1273
1274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1275 write!(formatter, "expected one of: {:?}", &FIELDS)
1276 }
1277
1278 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1279 where
1280 E: serde::de::Error,
1281 {
1282 i32::try_from(v)
1283 .ok()
1284 .and_then(|x| x.try_into().ok())
1285 .ok_or_else(|| {
1286 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1287 })
1288 }
1289
1290 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1291 where
1292 E: serde::de::Error,
1293 {
1294 i32::try_from(v)
1295 .ok()
1296 .and_then(|x| x.try_into().ok())
1297 .ok_or_else(|| {
1298 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1299 })
1300 }
1301
1302 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1303 where
1304 E: serde::de::Error,
1305 {
1306 match value {
1307 "UNSPECIFIED" => Ok(compact_task::TaskStatus::Unspecified),
1308 "PENDING" => Ok(compact_task::TaskStatus::Pending),
1309 "SUCCESS" => Ok(compact_task::TaskStatus::Success),
1310 "HEARTBEAT_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatCanceled),
1311 "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailMemoryResourceCanceled),
1312 "ASSIGN_FAIL_CANCELED" => Ok(compact_task::TaskStatus::AssignFailCanceled),
1313 "SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::SendFailCanceled),
1314 "MANUAL_CANCELED" => Ok(compact_task::TaskStatus::ManualCanceled),
1315 "INVALID_GROUP_CANCELED" => Ok(compact_task::TaskStatus::InvalidGroupCanceled),
1316 "INPUT_OUTDATED_CANCELED" => Ok(compact_task::TaskStatus::InputOutdatedCanceled),
1317 "EXECUTE_FAILED" => Ok(compact_task::TaskStatus::ExecuteFailed),
1318 "JOIN_HANDLE_FAILED" => Ok(compact_task::TaskStatus::JoinHandleFailed),
1319 "TRACK_SST_OBJECT_ID_FAILED" => Ok(compact_task::TaskStatus::TrackSstObjectIdFailed),
1320 "NO_AVAIL_CPU_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailCpuResourceCanceled),
1321 "HEARTBEAT_PROGRESS_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatProgressCanceled),
1322 "RETENTION_TIME_REJECTED" => Ok(compact_task::TaskStatus::RetentionTimeRejected),
1323 "SERVERLESS_SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::ServerlessSendFailCanceled),
1324 "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => Ok(compact_task::TaskStatus::ServerlessTableNotFoundCanceled),
1325 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1326 }
1327 }
1328 }
1329 deserializer.deserialize_any(GeneratedVisitor)
1330 }
1331}
1332impl serde::Serialize for compact_task::TaskType {
1333 #[allow(deprecated)]
1334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1335 where
1336 S: serde::Serializer,
1337 {
1338 let variant = match self {
1339 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1340 Self::Dynamic => "DYNAMIC",
1341 Self::SpaceReclaim => "SPACE_RECLAIM",
1342 Self::Manual => "MANUAL",
1343 Self::SharedBuffer => "SHARED_BUFFER",
1344 Self::Ttl => "TTL",
1345 Self::Tombstone => "TOMBSTONE",
1346 Self::Emergency => "EMERGENCY",
1347 Self::VnodeWatermark => "VNODE_WATERMARK",
1348 };
1349 serializer.serialize_str(variant)
1350 }
1351}
1352impl<'de> serde::Deserialize<'de> for compact_task::TaskType {
1353 #[allow(deprecated)]
1354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1355 where
1356 D: serde::Deserializer<'de>,
1357 {
1358 const FIELDS: &[&str] = &[
1359 "TYPE_UNSPECIFIED",
1360 "DYNAMIC",
1361 "SPACE_RECLAIM",
1362 "MANUAL",
1363 "SHARED_BUFFER",
1364 "TTL",
1365 "TOMBSTONE",
1366 "EMERGENCY",
1367 "VNODE_WATERMARK",
1368 ];
1369
1370 struct GeneratedVisitor;
1371
1372 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1373 type Value = compact_task::TaskType;
1374
1375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1376 write!(formatter, "expected one of: {:?}", &FIELDS)
1377 }
1378
1379 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1380 where
1381 E: serde::de::Error,
1382 {
1383 i32::try_from(v)
1384 .ok()
1385 .and_then(|x| x.try_into().ok())
1386 .ok_or_else(|| {
1387 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1388 })
1389 }
1390
1391 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1392 where
1393 E: serde::de::Error,
1394 {
1395 i32::try_from(v)
1396 .ok()
1397 .and_then(|x| x.try_into().ok())
1398 .ok_or_else(|| {
1399 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1400 })
1401 }
1402
1403 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1404 where
1405 E: serde::de::Error,
1406 {
1407 match value {
1408 "TYPE_UNSPECIFIED" => Ok(compact_task::TaskType::TypeUnspecified),
1409 "DYNAMIC" => Ok(compact_task::TaskType::Dynamic),
1410 "SPACE_RECLAIM" => Ok(compact_task::TaskType::SpaceReclaim),
1411 "MANUAL" => Ok(compact_task::TaskType::Manual),
1412 "SHARED_BUFFER" => Ok(compact_task::TaskType::SharedBuffer),
1413 "TTL" => Ok(compact_task::TaskType::Ttl),
1414 "TOMBSTONE" => Ok(compact_task::TaskType::Tombstone),
1415 "EMERGENCY" => Ok(compact_task::TaskType::Emergency),
1416 "VNODE_WATERMARK" => Ok(compact_task::TaskType::VnodeWatermark),
1417 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1418 }
1419 }
1420 }
1421 deserializer.deserialize_any(GeneratedVisitor)
1422 }
1423}
1424impl serde::Serialize for CompactTaskAssignment {
1425 #[allow(deprecated)]
1426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1427 where
1428 S: serde::Serializer,
1429 {
1430 use serde::ser::SerializeStruct;
1431 let mut len = 0;
1432 if self.compact_task.is_some() {
1433 len += 1;
1434 }
1435 if self.context_id != 0 {
1436 len += 1;
1437 }
1438 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskAssignment", len)?;
1439 if let Some(v) = self.compact_task.as_ref() {
1440 struct_ser.serialize_field("compactTask", v)?;
1441 }
1442 if self.context_id != 0 {
1443 struct_ser.serialize_field("contextId", &self.context_id)?;
1444 }
1445 struct_ser.end()
1446 }
1447}
1448impl<'de> serde::Deserialize<'de> for CompactTaskAssignment {
1449 #[allow(deprecated)]
1450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1451 where
1452 D: serde::Deserializer<'de>,
1453 {
1454 const FIELDS: &[&str] = &[
1455 "compact_task",
1456 "compactTask",
1457 "context_id",
1458 "contextId",
1459 ];
1460
1461 #[allow(clippy::enum_variant_names)]
1462 enum GeneratedField {
1463 CompactTask,
1464 ContextId,
1465 }
1466 impl<'de> serde::Deserialize<'de> for GeneratedField {
1467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1468 where
1469 D: serde::Deserializer<'de>,
1470 {
1471 struct GeneratedVisitor;
1472
1473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1474 type Value = GeneratedField;
1475
1476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1477 write!(formatter, "expected one of: {:?}", &FIELDS)
1478 }
1479
1480 #[allow(unused_variables)]
1481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1482 where
1483 E: serde::de::Error,
1484 {
1485 match value {
1486 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
1487 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
1488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1489 }
1490 }
1491 }
1492 deserializer.deserialize_identifier(GeneratedVisitor)
1493 }
1494 }
1495 struct GeneratedVisitor;
1496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1497 type Value = CompactTaskAssignment;
1498
1499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1500 formatter.write_str("struct hummock.CompactTaskAssignment")
1501 }
1502
1503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskAssignment, V::Error>
1504 where
1505 V: serde::de::MapAccess<'de>,
1506 {
1507 let mut compact_task__ = None;
1508 let mut context_id__ = None;
1509 while let Some(k) = map_.next_key()? {
1510 match k {
1511 GeneratedField::CompactTask => {
1512 if compact_task__.is_some() {
1513 return Err(serde::de::Error::duplicate_field("compactTask"));
1514 }
1515 compact_task__ = map_.next_value()?;
1516 }
1517 GeneratedField::ContextId => {
1518 if context_id__.is_some() {
1519 return Err(serde::de::Error::duplicate_field("contextId"));
1520 }
1521 context_id__ =
1522 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1523 ;
1524 }
1525 }
1526 }
1527 Ok(CompactTaskAssignment {
1528 compact_task: compact_task__,
1529 context_id: context_id__.unwrap_or_default(),
1530 })
1531 }
1532 }
1533 deserializer.deserialize_struct("hummock.CompactTaskAssignment", FIELDS, GeneratedVisitor)
1534 }
1535}
1536impl serde::Serialize for CompactTaskProgress {
1537 #[allow(deprecated)]
1538 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1539 where
1540 S: serde::Serializer,
1541 {
1542 use serde::ser::SerializeStruct;
1543 let mut len = 0;
1544 if self.task_id != 0 {
1545 len += 1;
1546 }
1547 if self.num_ssts_sealed != 0 {
1548 len += 1;
1549 }
1550 if self.num_ssts_uploaded != 0 {
1551 len += 1;
1552 }
1553 if self.num_progress_key != 0 {
1554 len += 1;
1555 }
1556 if self.num_pending_read_io != 0 {
1557 len += 1;
1558 }
1559 if self.num_pending_write_io != 0 {
1560 len += 1;
1561 }
1562 if self.compaction_group_id.is_some() {
1563 len += 1;
1564 }
1565 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskProgress", len)?;
1566 if self.task_id != 0 {
1567 #[allow(clippy::needless_borrow)]
1568 #[allow(clippy::needless_borrows_for_generic_args)]
1569 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
1570 }
1571 if self.num_ssts_sealed != 0 {
1572 struct_ser.serialize_field("numSstsSealed", &self.num_ssts_sealed)?;
1573 }
1574 if self.num_ssts_uploaded != 0 {
1575 struct_ser.serialize_field("numSstsUploaded", &self.num_ssts_uploaded)?;
1576 }
1577 if self.num_progress_key != 0 {
1578 #[allow(clippy::needless_borrow)]
1579 #[allow(clippy::needless_borrows_for_generic_args)]
1580 struct_ser.serialize_field("numProgressKey", ToString::to_string(&self.num_progress_key).as_str())?;
1581 }
1582 if self.num_pending_read_io != 0 {
1583 #[allow(clippy::needless_borrow)]
1584 #[allow(clippy::needless_borrows_for_generic_args)]
1585 struct_ser.serialize_field("numPendingReadIo", ToString::to_string(&self.num_pending_read_io).as_str())?;
1586 }
1587 if self.num_pending_write_io != 0 {
1588 #[allow(clippy::needless_borrow)]
1589 #[allow(clippy::needless_borrows_for_generic_args)]
1590 struct_ser.serialize_field("numPendingWriteIo", ToString::to_string(&self.num_pending_write_io).as_str())?;
1591 }
1592 if let Some(v) = self.compaction_group_id.as_ref() {
1593 #[allow(clippy::needless_borrow)]
1594 #[allow(clippy::needless_borrows_for_generic_args)]
1595 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&v).as_str())?;
1596 }
1597 struct_ser.end()
1598 }
1599}
1600impl<'de> serde::Deserialize<'de> for CompactTaskProgress {
1601 #[allow(deprecated)]
1602 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1603 where
1604 D: serde::Deserializer<'de>,
1605 {
1606 const FIELDS: &[&str] = &[
1607 "task_id",
1608 "taskId",
1609 "num_ssts_sealed",
1610 "numSstsSealed",
1611 "num_ssts_uploaded",
1612 "numSstsUploaded",
1613 "num_progress_key",
1614 "numProgressKey",
1615 "num_pending_read_io",
1616 "numPendingReadIo",
1617 "num_pending_write_io",
1618 "numPendingWriteIo",
1619 "compaction_group_id",
1620 "compactionGroupId",
1621 ];
1622
1623 #[allow(clippy::enum_variant_names)]
1624 enum GeneratedField {
1625 TaskId,
1626 NumSstsSealed,
1627 NumSstsUploaded,
1628 NumProgressKey,
1629 NumPendingReadIo,
1630 NumPendingWriteIo,
1631 CompactionGroupId,
1632 }
1633 impl<'de> serde::Deserialize<'de> for GeneratedField {
1634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1635 where
1636 D: serde::Deserializer<'de>,
1637 {
1638 struct GeneratedVisitor;
1639
1640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1641 type Value = GeneratedField;
1642
1643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1644 write!(formatter, "expected one of: {:?}", &FIELDS)
1645 }
1646
1647 #[allow(unused_variables)]
1648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1649 where
1650 E: serde::de::Error,
1651 {
1652 match value {
1653 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1654 "numSstsSealed" | "num_ssts_sealed" => Ok(GeneratedField::NumSstsSealed),
1655 "numSstsUploaded" | "num_ssts_uploaded" => Ok(GeneratedField::NumSstsUploaded),
1656 "numProgressKey" | "num_progress_key" => Ok(GeneratedField::NumProgressKey),
1657 "numPendingReadIo" | "num_pending_read_io" => Ok(GeneratedField::NumPendingReadIo),
1658 "numPendingWriteIo" | "num_pending_write_io" => Ok(GeneratedField::NumPendingWriteIo),
1659 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1660 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1661 }
1662 }
1663 }
1664 deserializer.deserialize_identifier(GeneratedVisitor)
1665 }
1666 }
1667 struct GeneratedVisitor;
1668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1669 type Value = CompactTaskProgress;
1670
1671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1672 formatter.write_str("struct hummock.CompactTaskProgress")
1673 }
1674
1675 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskProgress, V::Error>
1676 where
1677 V: serde::de::MapAccess<'de>,
1678 {
1679 let mut task_id__ = None;
1680 let mut num_ssts_sealed__ = None;
1681 let mut num_ssts_uploaded__ = None;
1682 let mut num_progress_key__ = None;
1683 let mut num_pending_read_io__ = None;
1684 let mut num_pending_write_io__ = None;
1685 let mut compaction_group_id__ = None;
1686 while let Some(k) = map_.next_key()? {
1687 match k {
1688 GeneratedField::TaskId => {
1689 if task_id__.is_some() {
1690 return Err(serde::de::Error::duplicate_field("taskId"));
1691 }
1692 task_id__ =
1693 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1694 ;
1695 }
1696 GeneratedField::NumSstsSealed => {
1697 if num_ssts_sealed__.is_some() {
1698 return Err(serde::de::Error::duplicate_field("numSstsSealed"));
1699 }
1700 num_ssts_sealed__ =
1701 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1702 ;
1703 }
1704 GeneratedField::NumSstsUploaded => {
1705 if num_ssts_uploaded__.is_some() {
1706 return Err(serde::de::Error::duplicate_field("numSstsUploaded"));
1707 }
1708 num_ssts_uploaded__ =
1709 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1710 ;
1711 }
1712 GeneratedField::NumProgressKey => {
1713 if num_progress_key__.is_some() {
1714 return Err(serde::de::Error::duplicate_field("numProgressKey"));
1715 }
1716 num_progress_key__ =
1717 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1718 ;
1719 }
1720 GeneratedField::NumPendingReadIo => {
1721 if num_pending_read_io__.is_some() {
1722 return Err(serde::de::Error::duplicate_field("numPendingReadIo"));
1723 }
1724 num_pending_read_io__ =
1725 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1726 ;
1727 }
1728 GeneratedField::NumPendingWriteIo => {
1729 if num_pending_write_io__.is_some() {
1730 return Err(serde::de::Error::duplicate_field("numPendingWriteIo"));
1731 }
1732 num_pending_write_io__ =
1733 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1734 ;
1735 }
1736 GeneratedField::CompactionGroupId => {
1737 if compaction_group_id__.is_some() {
1738 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1739 }
1740 compaction_group_id__ =
1741 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1742 ;
1743 }
1744 }
1745 }
1746 Ok(CompactTaskProgress {
1747 task_id: task_id__.unwrap_or_default(),
1748 num_ssts_sealed: num_ssts_sealed__.unwrap_or_default(),
1749 num_ssts_uploaded: num_ssts_uploaded__.unwrap_or_default(),
1750 num_progress_key: num_progress_key__.unwrap_or_default(),
1751 num_pending_read_io: num_pending_read_io__.unwrap_or_default(),
1752 num_pending_write_io: num_pending_write_io__.unwrap_or_default(),
1753 compaction_group_id: compaction_group_id__,
1754 })
1755 }
1756 }
1757 deserializer.deserialize_struct("hummock.CompactTaskProgress", FIELDS, GeneratedVisitor)
1758 }
1759}
1760impl serde::Serialize for CompactionConfig {
1761 #[allow(deprecated)]
1762 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1763 where
1764 S: serde::Serializer,
1765 {
1766 use serde::ser::SerializeStruct;
1767 let mut len = 0;
1768 if self.max_bytes_for_level_base != 0 {
1769 len += 1;
1770 }
1771 if self.max_level != 0 {
1772 len += 1;
1773 }
1774 if self.max_bytes_for_level_multiplier != 0 {
1775 len += 1;
1776 }
1777 if self.max_compaction_bytes != 0 {
1778 len += 1;
1779 }
1780 if self.sub_level_max_compaction_bytes != 0 {
1781 len += 1;
1782 }
1783 if self.level0_tier_compact_file_number != 0 {
1784 len += 1;
1785 }
1786 if self.compaction_mode != 0 {
1787 len += 1;
1788 }
1789 if !self.compression_algorithm.is_empty() {
1790 len += 1;
1791 }
1792 if self.target_file_size_base != 0 {
1793 len += 1;
1794 }
1795 if self.compaction_filter_mask != 0 {
1796 len += 1;
1797 }
1798 if self.max_sub_compaction != 0 {
1799 len += 1;
1800 }
1801 if self.max_space_reclaim_bytes != 0 {
1802 len += 1;
1803 }
1804 if self.split_by_state_table {
1805 len += 1;
1806 }
1807 if self.split_weight_by_vnode != 0 {
1808 len += 1;
1809 }
1810 if self.level0_stop_write_threshold_sub_level_number != 0 {
1811 len += 1;
1812 }
1813 if self.level0_max_compact_file_number != 0 {
1814 len += 1;
1815 }
1816 if self.level0_sub_level_compact_level_count != 0 {
1817 len += 1;
1818 }
1819 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1820 len += 1;
1821 }
1822 if self.tombstone_reclaim_ratio != 0 {
1823 len += 1;
1824 }
1825 if self.enable_emergency_picker {
1826 len += 1;
1827 }
1828 if self.max_l0_compact_level_count.is_some() {
1829 len += 1;
1830 }
1831 if self.sst_allowed_trivial_move_min_size.is_some() {
1832 len += 1;
1833 }
1834 if self.disable_auto_group_scheduling.is_some() {
1835 len += 1;
1836 }
1837 if self.max_overlapping_level_size.is_some() {
1838 len += 1;
1839 }
1840 if self.emergency_level0_sst_file_count.is_some() {
1841 len += 1;
1842 }
1843 if self.emergency_level0_sub_level_partition.is_some() {
1844 len += 1;
1845 }
1846 if self.level0_stop_write_threshold_max_sst_count.is_some() {
1847 len += 1;
1848 }
1849 if self.level0_stop_write_threshold_max_size.is_some() {
1850 len += 1;
1851 }
1852 if self.sst_allowed_trivial_move_max_count.is_some() {
1853 len += 1;
1854 }
1855 if self.enable_optimize_l0_interval_selection.is_some() {
1856 len += 1;
1857 }
1858 let mut struct_ser = serializer.serialize_struct("hummock.CompactionConfig", len)?;
1859 if self.max_bytes_for_level_base != 0 {
1860 #[allow(clippy::needless_borrow)]
1861 #[allow(clippy::needless_borrows_for_generic_args)]
1862 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&self.max_bytes_for_level_base).as_str())?;
1863 }
1864 if self.max_level != 0 {
1865 #[allow(clippy::needless_borrow)]
1866 #[allow(clippy::needless_borrows_for_generic_args)]
1867 struct_ser.serialize_field("maxLevel", ToString::to_string(&self.max_level).as_str())?;
1868 }
1869 if self.max_bytes_for_level_multiplier != 0 {
1870 #[allow(clippy::needless_borrow)]
1871 #[allow(clippy::needless_borrows_for_generic_args)]
1872 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&self.max_bytes_for_level_multiplier).as_str())?;
1873 }
1874 if self.max_compaction_bytes != 0 {
1875 #[allow(clippy::needless_borrow)]
1876 #[allow(clippy::needless_borrows_for_generic_args)]
1877 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&self.max_compaction_bytes).as_str())?;
1878 }
1879 if self.sub_level_max_compaction_bytes != 0 {
1880 #[allow(clippy::needless_borrow)]
1881 #[allow(clippy::needless_borrows_for_generic_args)]
1882 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&self.sub_level_max_compaction_bytes).as_str())?;
1883 }
1884 if self.level0_tier_compact_file_number != 0 {
1885 #[allow(clippy::needless_borrow)]
1886 #[allow(clippy::needless_borrows_for_generic_args)]
1887 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&self.level0_tier_compact_file_number).as_str())?;
1888 }
1889 if self.compaction_mode != 0 {
1890 let v = compaction_config::CompactionMode::try_from(self.compaction_mode)
1891 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compaction_mode)))?;
1892 struct_ser.serialize_field("compactionMode", &v)?;
1893 }
1894 if !self.compression_algorithm.is_empty() {
1895 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
1896 }
1897 if self.target_file_size_base != 0 {
1898 #[allow(clippy::needless_borrow)]
1899 #[allow(clippy::needless_borrows_for_generic_args)]
1900 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&self.target_file_size_base).as_str())?;
1901 }
1902 if self.compaction_filter_mask != 0 {
1903 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
1904 }
1905 if self.max_sub_compaction != 0 {
1906 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
1907 }
1908 if self.max_space_reclaim_bytes != 0 {
1909 #[allow(clippy::needless_borrow)]
1910 #[allow(clippy::needless_borrows_for_generic_args)]
1911 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&self.max_space_reclaim_bytes).as_str())?;
1912 }
1913 if self.split_by_state_table {
1914 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
1915 }
1916 if self.split_weight_by_vnode != 0 {
1917 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
1918 }
1919 if self.level0_stop_write_threshold_sub_level_number != 0 {
1920 #[allow(clippy::needless_borrow)]
1921 #[allow(clippy::needless_borrows_for_generic_args)]
1922 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&self.level0_stop_write_threshold_sub_level_number).as_str())?;
1923 }
1924 if self.level0_max_compact_file_number != 0 {
1925 #[allow(clippy::needless_borrow)]
1926 #[allow(clippy::needless_borrows_for_generic_args)]
1927 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&self.level0_max_compact_file_number).as_str())?;
1928 }
1929 if self.level0_sub_level_compact_level_count != 0 {
1930 struct_ser.serialize_field("level0SubLevelCompactLevelCount", &self.level0_sub_level_compact_level_count)?;
1931 }
1932 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1933 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", &self.level0_overlapping_sub_level_compact_level_count)?;
1934 }
1935 if self.tombstone_reclaim_ratio != 0 {
1936 struct_ser.serialize_field("tombstoneReclaimRatio", &self.tombstone_reclaim_ratio)?;
1937 }
1938 if self.enable_emergency_picker {
1939 struct_ser.serialize_field("enableEmergencyPicker", &self.enable_emergency_picker)?;
1940 }
1941 if let Some(v) = self.max_l0_compact_level_count.as_ref() {
1942 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
1943 }
1944 if let Some(v) = self.sst_allowed_trivial_move_min_size.as_ref() {
1945 #[allow(clippy::needless_borrow)]
1946 #[allow(clippy::needless_borrows_for_generic_args)]
1947 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
1948 }
1949 if let Some(v) = self.disable_auto_group_scheduling.as_ref() {
1950 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
1951 }
1952 if let Some(v) = self.max_overlapping_level_size.as_ref() {
1953 #[allow(clippy::needless_borrow)]
1954 #[allow(clippy::needless_borrows_for_generic_args)]
1955 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
1956 }
1957 if let Some(v) = self.emergency_level0_sst_file_count.as_ref() {
1958 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
1959 }
1960 if let Some(v) = self.emergency_level0_sub_level_partition.as_ref() {
1961 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
1962 }
1963 if let Some(v) = self.level0_stop_write_threshold_max_sst_count.as_ref() {
1964 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
1965 }
1966 if let Some(v) = self.level0_stop_write_threshold_max_size.as_ref() {
1967 #[allow(clippy::needless_borrow)]
1968 #[allow(clippy::needless_borrows_for_generic_args)]
1969 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
1970 }
1971 if let Some(v) = self.sst_allowed_trivial_move_max_count.as_ref() {
1972 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
1973 }
1974 if let Some(v) = self.enable_optimize_l0_interval_selection.as_ref() {
1975 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
1976 }
1977 struct_ser.end()
1978 }
1979}
1980impl<'de> serde::Deserialize<'de> for CompactionConfig {
1981 #[allow(deprecated)]
1982 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1983 where
1984 D: serde::Deserializer<'de>,
1985 {
1986 const FIELDS: &[&str] = &[
1987 "max_bytes_for_level_base",
1988 "maxBytesForLevelBase",
1989 "max_level",
1990 "maxLevel",
1991 "max_bytes_for_level_multiplier",
1992 "maxBytesForLevelMultiplier",
1993 "max_compaction_bytes",
1994 "maxCompactionBytes",
1995 "sub_level_max_compaction_bytes",
1996 "subLevelMaxCompactionBytes",
1997 "level0_tier_compact_file_number",
1998 "level0TierCompactFileNumber",
1999 "compaction_mode",
2000 "compactionMode",
2001 "compression_algorithm",
2002 "compressionAlgorithm",
2003 "target_file_size_base",
2004 "targetFileSizeBase",
2005 "compaction_filter_mask",
2006 "compactionFilterMask",
2007 "max_sub_compaction",
2008 "maxSubCompaction",
2009 "max_space_reclaim_bytes",
2010 "maxSpaceReclaimBytes",
2011 "split_by_state_table",
2012 "splitByStateTable",
2013 "split_weight_by_vnode",
2014 "splitWeightByVnode",
2015 "level0_stop_write_threshold_sub_level_number",
2016 "level0StopWriteThresholdSubLevelNumber",
2017 "level0_max_compact_file_number",
2018 "level0MaxCompactFileNumber",
2019 "level0_sub_level_compact_level_count",
2020 "level0SubLevelCompactLevelCount",
2021 "level0_overlapping_sub_level_compact_level_count",
2022 "level0OverlappingSubLevelCompactLevelCount",
2023 "tombstone_reclaim_ratio",
2024 "tombstoneReclaimRatio",
2025 "enable_emergency_picker",
2026 "enableEmergencyPicker",
2027 "max_l0_compact_level_count",
2028 "maxL0CompactLevelCount",
2029 "sst_allowed_trivial_move_min_size",
2030 "sstAllowedTrivialMoveMinSize",
2031 "disable_auto_group_scheduling",
2032 "disableAutoGroupScheduling",
2033 "max_overlapping_level_size",
2034 "maxOverlappingLevelSize",
2035 "emergency_level0_sst_file_count",
2036 "emergencyLevel0SstFileCount",
2037 "emergency_level0_sub_level_partition",
2038 "emergencyLevel0SubLevelPartition",
2039 "level0_stop_write_threshold_max_sst_count",
2040 "level0StopWriteThresholdMaxSstCount",
2041 "level0_stop_write_threshold_max_size",
2042 "level0StopWriteThresholdMaxSize",
2043 "sst_allowed_trivial_move_max_count",
2044 "sstAllowedTrivialMoveMaxCount",
2045 "enable_optimize_l0_interval_selection",
2046 "enableOptimizeL0IntervalSelection",
2047 ];
2048
2049 #[allow(clippy::enum_variant_names)]
2050 enum GeneratedField {
2051 MaxBytesForLevelBase,
2052 MaxLevel,
2053 MaxBytesForLevelMultiplier,
2054 MaxCompactionBytes,
2055 SubLevelMaxCompactionBytes,
2056 Level0TierCompactFileNumber,
2057 CompactionMode,
2058 CompressionAlgorithm,
2059 TargetFileSizeBase,
2060 CompactionFilterMask,
2061 MaxSubCompaction,
2062 MaxSpaceReclaimBytes,
2063 SplitByStateTable,
2064 SplitWeightByVnode,
2065 Level0StopWriteThresholdSubLevelNumber,
2066 Level0MaxCompactFileNumber,
2067 Level0SubLevelCompactLevelCount,
2068 Level0OverlappingSubLevelCompactLevelCount,
2069 TombstoneReclaimRatio,
2070 EnableEmergencyPicker,
2071 MaxL0CompactLevelCount,
2072 SstAllowedTrivialMoveMinSize,
2073 DisableAutoGroupScheduling,
2074 MaxOverlappingLevelSize,
2075 EmergencyLevel0SstFileCount,
2076 EmergencyLevel0SubLevelPartition,
2077 Level0StopWriteThresholdMaxSstCount,
2078 Level0StopWriteThresholdMaxSize,
2079 SstAllowedTrivialMoveMaxCount,
2080 EnableOptimizeL0IntervalSelection,
2081 }
2082 impl<'de> serde::Deserialize<'de> for GeneratedField {
2083 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2084 where
2085 D: serde::Deserializer<'de>,
2086 {
2087 struct GeneratedVisitor;
2088
2089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2090 type Value = GeneratedField;
2091
2092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2093 write!(formatter, "expected one of: {:?}", &FIELDS)
2094 }
2095
2096 #[allow(unused_variables)]
2097 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2098 where
2099 E: serde::de::Error,
2100 {
2101 match value {
2102 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
2103 "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2104 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
2105 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
2106 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
2107 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
2108 "compactionMode" | "compaction_mode" => Ok(GeneratedField::CompactionMode),
2109 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
2110 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
2111 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
2112 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
2113 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
2114 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
2115 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
2116 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
2117 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
2118 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
2119 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
2120 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
2121 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
2122 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
2123 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
2124 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
2125 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
2126 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
2127 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
2128 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
2129 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
2130 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
2131 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
2132 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2133 }
2134 }
2135 }
2136 deserializer.deserialize_identifier(GeneratedVisitor)
2137 }
2138 }
2139 struct GeneratedVisitor;
2140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2141 type Value = CompactionConfig;
2142
2143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2144 formatter.write_str("struct hummock.CompactionConfig")
2145 }
2146
2147 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionConfig, V::Error>
2148 where
2149 V: serde::de::MapAccess<'de>,
2150 {
2151 let mut max_bytes_for_level_base__ = None;
2152 let mut max_level__ = None;
2153 let mut max_bytes_for_level_multiplier__ = None;
2154 let mut max_compaction_bytes__ = None;
2155 let mut sub_level_max_compaction_bytes__ = None;
2156 let mut level0_tier_compact_file_number__ = None;
2157 let mut compaction_mode__ = None;
2158 let mut compression_algorithm__ = None;
2159 let mut target_file_size_base__ = None;
2160 let mut compaction_filter_mask__ = None;
2161 let mut max_sub_compaction__ = None;
2162 let mut max_space_reclaim_bytes__ = None;
2163 let mut split_by_state_table__ = None;
2164 let mut split_weight_by_vnode__ = None;
2165 let mut level0_stop_write_threshold_sub_level_number__ = None;
2166 let mut level0_max_compact_file_number__ = None;
2167 let mut level0_sub_level_compact_level_count__ = None;
2168 let mut level0_overlapping_sub_level_compact_level_count__ = None;
2169 let mut tombstone_reclaim_ratio__ = None;
2170 let mut enable_emergency_picker__ = None;
2171 let mut max_l0_compact_level_count__ = None;
2172 let mut sst_allowed_trivial_move_min_size__ = None;
2173 let mut disable_auto_group_scheduling__ = None;
2174 let mut max_overlapping_level_size__ = None;
2175 let mut emergency_level0_sst_file_count__ = None;
2176 let mut emergency_level0_sub_level_partition__ = None;
2177 let mut level0_stop_write_threshold_max_sst_count__ = None;
2178 let mut level0_stop_write_threshold_max_size__ = None;
2179 let mut sst_allowed_trivial_move_max_count__ = None;
2180 let mut enable_optimize_l0_interval_selection__ = None;
2181 while let Some(k) = map_.next_key()? {
2182 match k {
2183 GeneratedField::MaxBytesForLevelBase => {
2184 if max_bytes_for_level_base__.is_some() {
2185 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
2186 }
2187 max_bytes_for_level_base__ =
2188 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2189 ;
2190 }
2191 GeneratedField::MaxLevel => {
2192 if max_level__.is_some() {
2193 return Err(serde::de::Error::duplicate_field("maxLevel"));
2194 }
2195 max_level__ =
2196 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2197 ;
2198 }
2199 GeneratedField::MaxBytesForLevelMultiplier => {
2200 if max_bytes_for_level_multiplier__.is_some() {
2201 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
2202 }
2203 max_bytes_for_level_multiplier__ =
2204 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2205 ;
2206 }
2207 GeneratedField::MaxCompactionBytes => {
2208 if max_compaction_bytes__.is_some() {
2209 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
2210 }
2211 max_compaction_bytes__ =
2212 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2213 ;
2214 }
2215 GeneratedField::SubLevelMaxCompactionBytes => {
2216 if sub_level_max_compaction_bytes__.is_some() {
2217 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
2218 }
2219 sub_level_max_compaction_bytes__ =
2220 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2221 ;
2222 }
2223 GeneratedField::Level0TierCompactFileNumber => {
2224 if level0_tier_compact_file_number__.is_some() {
2225 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
2226 }
2227 level0_tier_compact_file_number__ =
2228 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2229 ;
2230 }
2231 GeneratedField::CompactionMode => {
2232 if compaction_mode__.is_some() {
2233 return Err(serde::de::Error::duplicate_field("compactionMode"));
2234 }
2235 compaction_mode__ = Some(map_.next_value::<compaction_config::CompactionMode>()? as i32);
2236 }
2237 GeneratedField::CompressionAlgorithm => {
2238 if compression_algorithm__.is_some() {
2239 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
2240 }
2241 compression_algorithm__ = Some(map_.next_value()?);
2242 }
2243 GeneratedField::TargetFileSizeBase => {
2244 if target_file_size_base__.is_some() {
2245 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
2246 }
2247 target_file_size_base__ =
2248 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2249 ;
2250 }
2251 GeneratedField::CompactionFilterMask => {
2252 if compaction_filter_mask__.is_some() {
2253 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
2254 }
2255 compaction_filter_mask__ =
2256 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2257 ;
2258 }
2259 GeneratedField::MaxSubCompaction => {
2260 if max_sub_compaction__.is_some() {
2261 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
2262 }
2263 max_sub_compaction__ =
2264 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2265 ;
2266 }
2267 GeneratedField::MaxSpaceReclaimBytes => {
2268 if max_space_reclaim_bytes__.is_some() {
2269 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
2270 }
2271 max_space_reclaim_bytes__ =
2272 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2273 ;
2274 }
2275 GeneratedField::SplitByStateTable => {
2276 if split_by_state_table__.is_some() {
2277 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
2278 }
2279 split_by_state_table__ = Some(map_.next_value()?);
2280 }
2281 GeneratedField::SplitWeightByVnode => {
2282 if split_weight_by_vnode__.is_some() {
2283 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
2284 }
2285 split_weight_by_vnode__ =
2286 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2287 ;
2288 }
2289 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
2290 if level0_stop_write_threshold_sub_level_number__.is_some() {
2291 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
2292 }
2293 level0_stop_write_threshold_sub_level_number__ =
2294 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2295 ;
2296 }
2297 GeneratedField::Level0MaxCompactFileNumber => {
2298 if level0_max_compact_file_number__.is_some() {
2299 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
2300 }
2301 level0_max_compact_file_number__ =
2302 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2303 ;
2304 }
2305 GeneratedField::Level0SubLevelCompactLevelCount => {
2306 if level0_sub_level_compact_level_count__.is_some() {
2307 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
2308 }
2309 level0_sub_level_compact_level_count__ =
2310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2311 ;
2312 }
2313 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
2314 if level0_overlapping_sub_level_compact_level_count__.is_some() {
2315 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
2316 }
2317 level0_overlapping_sub_level_compact_level_count__ =
2318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2319 ;
2320 }
2321 GeneratedField::TombstoneReclaimRatio => {
2322 if tombstone_reclaim_ratio__.is_some() {
2323 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
2324 }
2325 tombstone_reclaim_ratio__ =
2326 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2327 ;
2328 }
2329 GeneratedField::EnableEmergencyPicker => {
2330 if enable_emergency_picker__.is_some() {
2331 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
2332 }
2333 enable_emergency_picker__ = Some(map_.next_value()?);
2334 }
2335 GeneratedField::MaxL0CompactLevelCount => {
2336 if max_l0_compact_level_count__.is_some() {
2337 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
2338 }
2339 max_l0_compact_level_count__ =
2340 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2341 ;
2342 }
2343 GeneratedField::SstAllowedTrivialMoveMinSize => {
2344 if sst_allowed_trivial_move_min_size__.is_some() {
2345 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
2346 }
2347 sst_allowed_trivial_move_min_size__ =
2348 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2349 ;
2350 }
2351 GeneratedField::DisableAutoGroupScheduling => {
2352 if disable_auto_group_scheduling__.is_some() {
2353 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
2354 }
2355 disable_auto_group_scheduling__ = map_.next_value()?;
2356 }
2357 GeneratedField::MaxOverlappingLevelSize => {
2358 if max_overlapping_level_size__.is_some() {
2359 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
2360 }
2361 max_overlapping_level_size__ =
2362 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2363 ;
2364 }
2365 GeneratedField::EmergencyLevel0SstFileCount => {
2366 if emergency_level0_sst_file_count__.is_some() {
2367 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
2368 }
2369 emergency_level0_sst_file_count__ =
2370 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2371 ;
2372 }
2373 GeneratedField::EmergencyLevel0SubLevelPartition => {
2374 if emergency_level0_sub_level_partition__.is_some() {
2375 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
2376 }
2377 emergency_level0_sub_level_partition__ =
2378 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2379 ;
2380 }
2381 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
2382 if level0_stop_write_threshold_max_sst_count__.is_some() {
2383 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
2384 }
2385 level0_stop_write_threshold_max_sst_count__ =
2386 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2387 ;
2388 }
2389 GeneratedField::Level0StopWriteThresholdMaxSize => {
2390 if level0_stop_write_threshold_max_size__.is_some() {
2391 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
2392 }
2393 level0_stop_write_threshold_max_size__ =
2394 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2395 ;
2396 }
2397 GeneratedField::SstAllowedTrivialMoveMaxCount => {
2398 if sst_allowed_trivial_move_max_count__.is_some() {
2399 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
2400 }
2401 sst_allowed_trivial_move_max_count__ =
2402 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2403 ;
2404 }
2405 GeneratedField::EnableOptimizeL0IntervalSelection => {
2406 if enable_optimize_l0_interval_selection__.is_some() {
2407 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
2408 }
2409 enable_optimize_l0_interval_selection__ = map_.next_value()?;
2410 }
2411 }
2412 }
2413 Ok(CompactionConfig {
2414 max_bytes_for_level_base: max_bytes_for_level_base__.unwrap_or_default(),
2415 max_level: max_level__.unwrap_or_default(),
2416 max_bytes_for_level_multiplier: max_bytes_for_level_multiplier__.unwrap_or_default(),
2417 max_compaction_bytes: max_compaction_bytes__.unwrap_or_default(),
2418 sub_level_max_compaction_bytes: sub_level_max_compaction_bytes__.unwrap_or_default(),
2419 level0_tier_compact_file_number: level0_tier_compact_file_number__.unwrap_or_default(),
2420 compaction_mode: compaction_mode__.unwrap_or_default(),
2421 compression_algorithm: compression_algorithm__.unwrap_or_default(),
2422 target_file_size_base: target_file_size_base__.unwrap_or_default(),
2423 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
2424 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
2425 max_space_reclaim_bytes: max_space_reclaim_bytes__.unwrap_or_default(),
2426 split_by_state_table: split_by_state_table__.unwrap_or_default(),
2427 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
2428 level0_stop_write_threshold_sub_level_number: level0_stop_write_threshold_sub_level_number__.unwrap_or_default(),
2429 level0_max_compact_file_number: level0_max_compact_file_number__.unwrap_or_default(),
2430 level0_sub_level_compact_level_count: level0_sub_level_compact_level_count__.unwrap_or_default(),
2431 level0_overlapping_sub_level_compact_level_count: level0_overlapping_sub_level_compact_level_count__.unwrap_or_default(),
2432 tombstone_reclaim_ratio: tombstone_reclaim_ratio__.unwrap_or_default(),
2433 enable_emergency_picker: enable_emergency_picker__.unwrap_or_default(),
2434 max_l0_compact_level_count: max_l0_compact_level_count__,
2435 sst_allowed_trivial_move_min_size: sst_allowed_trivial_move_min_size__,
2436 disable_auto_group_scheduling: disable_auto_group_scheduling__,
2437 max_overlapping_level_size: max_overlapping_level_size__,
2438 emergency_level0_sst_file_count: emergency_level0_sst_file_count__,
2439 emergency_level0_sub_level_partition: emergency_level0_sub_level_partition__,
2440 level0_stop_write_threshold_max_sst_count: level0_stop_write_threshold_max_sst_count__,
2441 level0_stop_write_threshold_max_size: level0_stop_write_threshold_max_size__,
2442 sst_allowed_trivial_move_max_count: sst_allowed_trivial_move_max_count__,
2443 enable_optimize_l0_interval_selection: enable_optimize_l0_interval_selection__,
2444 })
2445 }
2446 }
2447 deserializer.deserialize_struct("hummock.CompactionConfig", FIELDS, GeneratedVisitor)
2448 }
2449}
2450impl serde::Serialize for compaction_config::CompactionMode {
2451 #[allow(deprecated)]
2452 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2453 where
2454 S: serde::Serializer,
2455 {
2456 let variant = match self {
2457 Self::Unspecified => "UNSPECIFIED",
2458 Self::Range => "RANGE",
2459 };
2460 serializer.serialize_str(variant)
2461 }
2462}
2463impl<'de> serde::Deserialize<'de> for compaction_config::CompactionMode {
2464 #[allow(deprecated)]
2465 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2466 where
2467 D: serde::Deserializer<'de>,
2468 {
2469 const FIELDS: &[&str] = &[
2470 "UNSPECIFIED",
2471 "RANGE",
2472 ];
2473
2474 struct GeneratedVisitor;
2475
2476 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2477 type Value = compaction_config::CompactionMode;
2478
2479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2480 write!(formatter, "expected one of: {:?}", &FIELDS)
2481 }
2482
2483 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2484 where
2485 E: serde::de::Error,
2486 {
2487 i32::try_from(v)
2488 .ok()
2489 .and_then(|x| x.try_into().ok())
2490 .ok_or_else(|| {
2491 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2492 })
2493 }
2494
2495 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2496 where
2497 E: serde::de::Error,
2498 {
2499 i32::try_from(v)
2500 .ok()
2501 .and_then(|x| x.try_into().ok())
2502 .ok_or_else(|| {
2503 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2504 })
2505 }
2506
2507 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2508 where
2509 E: serde::de::Error,
2510 {
2511 match value {
2512 "UNSPECIFIED" => Ok(compaction_config::CompactionMode::Unspecified),
2513 "RANGE" => Ok(compaction_config::CompactionMode::Range),
2514 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2515 }
2516 }
2517 }
2518 deserializer.deserialize_any(GeneratedVisitor)
2519 }
2520}
2521impl serde::Serialize for CompactionGroup {
2522 #[allow(deprecated)]
2523 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2524 where
2525 S: serde::Serializer,
2526 {
2527 use serde::ser::SerializeStruct;
2528 let mut len = 0;
2529 if self.id != 0 {
2530 len += 1;
2531 }
2532 if self.compaction_config.is_some() {
2533 len += 1;
2534 }
2535 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroup", len)?;
2536 if self.id != 0 {
2537 #[allow(clippy::needless_borrow)]
2538 #[allow(clippy::needless_borrows_for_generic_args)]
2539 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2540 }
2541 if let Some(v) = self.compaction_config.as_ref() {
2542 struct_ser.serialize_field("compactionConfig", v)?;
2543 }
2544 struct_ser.end()
2545 }
2546}
2547impl<'de> serde::Deserialize<'de> for CompactionGroup {
2548 #[allow(deprecated)]
2549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2550 where
2551 D: serde::Deserializer<'de>,
2552 {
2553 const FIELDS: &[&str] = &[
2554 "id",
2555 "compaction_config",
2556 "compactionConfig",
2557 ];
2558
2559 #[allow(clippy::enum_variant_names)]
2560 enum GeneratedField {
2561 Id,
2562 CompactionConfig,
2563 }
2564 impl<'de> serde::Deserialize<'de> for GeneratedField {
2565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2566 where
2567 D: serde::Deserializer<'de>,
2568 {
2569 struct GeneratedVisitor;
2570
2571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2572 type Value = GeneratedField;
2573
2574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2575 write!(formatter, "expected one of: {:?}", &FIELDS)
2576 }
2577
2578 #[allow(unused_variables)]
2579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2580 where
2581 E: serde::de::Error,
2582 {
2583 match value {
2584 "id" => Ok(GeneratedField::Id),
2585 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2586 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2587 }
2588 }
2589 }
2590 deserializer.deserialize_identifier(GeneratedVisitor)
2591 }
2592 }
2593 struct GeneratedVisitor;
2594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2595 type Value = CompactionGroup;
2596
2597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2598 formatter.write_str("struct hummock.CompactionGroup")
2599 }
2600
2601 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroup, V::Error>
2602 where
2603 V: serde::de::MapAccess<'de>,
2604 {
2605 let mut id__ = None;
2606 let mut compaction_config__ = None;
2607 while let Some(k) = map_.next_key()? {
2608 match k {
2609 GeneratedField::Id => {
2610 if id__.is_some() {
2611 return Err(serde::de::Error::duplicate_field("id"));
2612 }
2613 id__ =
2614 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2615 ;
2616 }
2617 GeneratedField::CompactionConfig => {
2618 if compaction_config__.is_some() {
2619 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2620 }
2621 compaction_config__ = map_.next_value()?;
2622 }
2623 }
2624 }
2625 Ok(CompactionGroup {
2626 id: id__.unwrap_or_default(),
2627 compaction_config: compaction_config__,
2628 })
2629 }
2630 }
2631 deserializer.deserialize_struct("hummock.CompactionGroup", FIELDS, GeneratedVisitor)
2632 }
2633}
2634impl serde::Serialize for CompactionGroupInfo {
2635 #[allow(deprecated)]
2636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2637 where
2638 S: serde::Serializer,
2639 {
2640 use serde::ser::SerializeStruct;
2641 let mut len = 0;
2642 if self.id != 0 {
2643 len += 1;
2644 }
2645 if self.parent_id != 0 {
2646 len += 1;
2647 }
2648 if !self.member_table_ids.is_empty() {
2649 len += 1;
2650 }
2651 if self.compaction_config.is_some() {
2652 len += 1;
2653 }
2654 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroupInfo", len)?;
2655 if self.id != 0 {
2656 #[allow(clippy::needless_borrow)]
2657 #[allow(clippy::needless_borrows_for_generic_args)]
2658 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2659 }
2660 if self.parent_id != 0 {
2661 #[allow(clippy::needless_borrow)]
2662 #[allow(clippy::needless_borrows_for_generic_args)]
2663 struct_ser.serialize_field("parentId", ToString::to_string(&self.parent_id).as_str())?;
2664 }
2665 if !self.member_table_ids.is_empty() {
2666 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
2667 }
2668 if let Some(v) = self.compaction_config.as_ref() {
2669 struct_ser.serialize_field("compactionConfig", v)?;
2670 }
2671 struct_ser.end()
2672 }
2673}
2674impl<'de> serde::Deserialize<'de> for CompactionGroupInfo {
2675 #[allow(deprecated)]
2676 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2677 where
2678 D: serde::Deserializer<'de>,
2679 {
2680 const FIELDS: &[&str] = &[
2681 "id",
2682 "parent_id",
2683 "parentId",
2684 "member_table_ids",
2685 "memberTableIds",
2686 "compaction_config",
2687 "compactionConfig",
2688 ];
2689
2690 #[allow(clippy::enum_variant_names)]
2691 enum GeneratedField {
2692 Id,
2693 ParentId,
2694 MemberTableIds,
2695 CompactionConfig,
2696 }
2697 impl<'de> serde::Deserialize<'de> for GeneratedField {
2698 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2699 where
2700 D: serde::Deserializer<'de>,
2701 {
2702 struct GeneratedVisitor;
2703
2704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2705 type Value = GeneratedField;
2706
2707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2708 write!(formatter, "expected one of: {:?}", &FIELDS)
2709 }
2710
2711 #[allow(unused_variables)]
2712 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2713 where
2714 E: serde::de::Error,
2715 {
2716 match value {
2717 "id" => Ok(GeneratedField::Id),
2718 "parentId" | "parent_id" => Ok(GeneratedField::ParentId),
2719 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
2720 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2721 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2722 }
2723 }
2724 }
2725 deserializer.deserialize_identifier(GeneratedVisitor)
2726 }
2727 }
2728 struct GeneratedVisitor;
2729 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2730 type Value = CompactionGroupInfo;
2731
2732 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2733 formatter.write_str("struct hummock.CompactionGroupInfo")
2734 }
2735
2736 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroupInfo, V::Error>
2737 where
2738 V: serde::de::MapAccess<'de>,
2739 {
2740 let mut id__ = None;
2741 let mut parent_id__ = None;
2742 let mut member_table_ids__ = None;
2743 let mut compaction_config__ = None;
2744 while let Some(k) = map_.next_key()? {
2745 match k {
2746 GeneratedField::Id => {
2747 if id__.is_some() {
2748 return Err(serde::de::Error::duplicate_field("id"));
2749 }
2750 id__ =
2751 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2752 ;
2753 }
2754 GeneratedField::ParentId => {
2755 if parent_id__.is_some() {
2756 return Err(serde::de::Error::duplicate_field("parentId"));
2757 }
2758 parent_id__ =
2759 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2760 ;
2761 }
2762 GeneratedField::MemberTableIds => {
2763 if member_table_ids__.is_some() {
2764 return Err(serde::de::Error::duplicate_field("memberTableIds"));
2765 }
2766 member_table_ids__ =
2767 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2768 .into_iter().map(|x| x.0).collect())
2769 ;
2770 }
2771 GeneratedField::CompactionConfig => {
2772 if compaction_config__.is_some() {
2773 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2774 }
2775 compaction_config__ = map_.next_value()?;
2776 }
2777 }
2778 }
2779 Ok(CompactionGroupInfo {
2780 id: id__.unwrap_or_default(),
2781 parent_id: parent_id__.unwrap_or_default(),
2782 member_table_ids: member_table_ids__.unwrap_or_default(),
2783 compaction_config: compaction_config__,
2784 })
2785 }
2786 }
2787 deserializer.deserialize_struct("hummock.CompactionGroupInfo", FIELDS, GeneratedVisitor)
2788 }
2789}
2790impl serde::Serialize for CompatibilityVersion {
2791 #[allow(deprecated)]
2792 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2793 where
2794 S: serde::Serializer,
2795 {
2796 let variant = match self {
2797 Self::VersionUnspecified => "VERSION_UNSPECIFIED",
2798 Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
2799 Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
2800 Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
2801 };
2802 serializer.serialize_str(variant)
2803 }
2804}
2805impl<'de> serde::Deserialize<'de> for CompatibilityVersion {
2806 #[allow(deprecated)]
2807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2808 where
2809 D: serde::Deserializer<'de>,
2810 {
2811 const FIELDS: &[&str] = &[
2812 "VERSION_UNSPECIFIED",
2813 "NO_TRIVIAL_SPLIT",
2814 "NO_MEMBER_TABLE_IDS",
2815 "SPLIT_GROUP_BY_TABLE_ID",
2816 ];
2817
2818 struct GeneratedVisitor;
2819
2820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2821 type Value = CompatibilityVersion;
2822
2823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2824 write!(formatter, "expected one of: {:?}", &FIELDS)
2825 }
2826
2827 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2828 where
2829 E: serde::de::Error,
2830 {
2831 i32::try_from(v)
2832 .ok()
2833 .and_then(|x| x.try_into().ok())
2834 .ok_or_else(|| {
2835 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2836 })
2837 }
2838
2839 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2840 where
2841 E: serde::de::Error,
2842 {
2843 i32::try_from(v)
2844 .ok()
2845 .and_then(|x| x.try_into().ok())
2846 .ok_or_else(|| {
2847 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2848 })
2849 }
2850
2851 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2852 where
2853 E: serde::de::Error,
2854 {
2855 match value {
2856 "VERSION_UNSPECIFIED" => Ok(CompatibilityVersion::VersionUnspecified),
2857 "NO_TRIVIAL_SPLIT" => Ok(CompatibilityVersion::NoTrivialSplit),
2858 "NO_MEMBER_TABLE_IDS" => Ok(CompatibilityVersion::NoMemberTableIds),
2859 "SPLIT_GROUP_BY_TABLE_ID" => Ok(CompatibilityVersion::SplitGroupByTableId),
2860 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2861 }
2862 }
2863 }
2864 deserializer.deserialize_any(GeneratedVisitor)
2865 }
2866}
2867impl serde::Serialize for DisableCommitEpochRequest {
2868 #[allow(deprecated)]
2869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2870 where
2871 S: serde::Serializer,
2872 {
2873 use serde::ser::SerializeStruct;
2874 let len = 0;
2875 let struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochRequest", len)?;
2876 struct_ser.end()
2877 }
2878}
2879impl<'de> serde::Deserialize<'de> for DisableCommitEpochRequest {
2880 #[allow(deprecated)]
2881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2882 where
2883 D: serde::Deserializer<'de>,
2884 {
2885 const FIELDS: &[&str] = &[
2886 ];
2887
2888 #[allow(clippy::enum_variant_names)]
2889 enum GeneratedField {
2890 }
2891 impl<'de> serde::Deserialize<'de> for GeneratedField {
2892 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2893 where
2894 D: serde::Deserializer<'de>,
2895 {
2896 struct GeneratedVisitor;
2897
2898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2899 type Value = GeneratedField;
2900
2901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2902 write!(formatter, "expected one of: {:?}", &FIELDS)
2903 }
2904
2905 #[allow(unused_variables)]
2906 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2907 where
2908 E: serde::de::Error,
2909 {
2910 Err(serde::de::Error::unknown_field(value, FIELDS))
2911 }
2912 }
2913 deserializer.deserialize_identifier(GeneratedVisitor)
2914 }
2915 }
2916 struct GeneratedVisitor;
2917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2918 type Value = DisableCommitEpochRequest;
2919
2920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2921 formatter.write_str("struct hummock.DisableCommitEpochRequest")
2922 }
2923
2924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochRequest, V::Error>
2925 where
2926 V: serde::de::MapAccess<'de>,
2927 {
2928 while map_.next_key::<GeneratedField>()?.is_some() {
2929 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2930 }
2931 Ok(DisableCommitEpochRequest {
2932 })
2933 }
2934 }
2935 deserializer.deserialize_struct("hummock.DisableCommitEpochRequest", FIELDS, GeneratedVisitor)
2936 }
2937}
2938impl serde::Serialize for DisableCommitEpochResponse {
2939 #[allow(deprecated)]
2940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2941 where
2942 S: serde::Serializer,
2943 {
2944 use serde::ser::SerializeStruct;
2945 let mut len = 0;
2946 if self.current_version.is_some() {
2947 len += 1;
2948 }
2949 let mut struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochResponse", len)?;
2950 if let Some(v) = self.current_version.as_ref() {
2951 struct_ser.serialize_field("currentVersion", v)?;
2952 }
2953 struct_ser.end()
2954 }
2955}
2956impl<'de> serde::Deserialize<'de> for DisableCommitEpochResponse {
2957 #[allow(deprecated)]
2958 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2959 where
2960 D: serde::Deserializer<'de>,
2961 {
2962 const FIELDS: &[&str] = &[
2963 "current_version",
2964 "currentVersion",
2965 ];
2966
2967 #[allow(clippy::enum_variant_names)]
2968 enum GeneratedField {
2969 CurrentVersion,
2970 }
2971 impl<'de> serde::Deserialize<'de> for GeneratedField {
2972 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2973 where
2974 D: serde::Deserializer<'de>,
2975 {
2976 struct GeneratedVisitor;
2977
2978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2979 type Value = GeneratedField;
2980
2981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2982 write!(formatter, "expected one of: {:?}", &FIELDS)
2983 }
2984
2985 #[allow(unused_variables)]
2986 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2987 where
2988 E: serde::de::Error,
2989 {
2990 match value {
2991 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
2992 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2993 }
2994 }
2995 }
2996 deserializer.deserialize_identifier(GeneratedVisitor)
2997 }
2998 }
2999 struct GeneratedVisitor;
3000 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3001 type Value = DisableCommitEpochResponse;
3002
3003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3004 formatter.write_str("struct hummock.DisableCommitEpochResponse")
3005 }
3006
3007 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochResponse, V::Error>
3008 where
3009 V: serde::de::MapAccess<'de>,
3010 {
3011 let mut current_version__ = None;
3012 while let Some(k) = map_.next_key()? {
3013 match k {
3014 GeneratedField::CurrentVersion => {
3015 if current_version__.is_some() {
3016 return Err(serde::de::Error::duplicate_field("currentVersion"));
3017 }
3018 current_version__ = map_.next_value()?;
3019 }
3020 }
3021 }
3022 Ok(DisableCommitEpochResponse {
3023 current_version: current_version__,
3024 })
3025 }
3026 }
3027 deserializer.deserialize_struct("hummock.DisableCommitEpochResponse", FIELDS, GeneratedVisitor)
3028 }
3029}
3030impl serde::Serialize for EpochNewChangeLog {
3031 #[allow(deprecated)]
3032 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3033 where
3034 S: serde::Serializer,
3035 {
3036 use serde::ser::SerializeStruct;
3037 let mut len = 0;
3038 if !self.old_value.is_empty() {
3039 len += 1;
3040 }
3041 if !self.new_value.is_empty() {
3042 len += 1;
3043 }
3044 if !self.epochs.is_empty() {
3045 len += 1;
3046 }
3047 let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3048 if !self.old_value.is_empty() {
3049 struct_ser.serialize_field("oldValue", &self.old_value)?;
3050 }
3051 if !self.new_value.is_empty() {
3052 struct_ser.serialize_field("newValue", &self.new_value)?;
3053 }
3054 if !self.epochs.is_empty() {
3055 struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3056 }
3057 struct_ser.end()
3058 }
3059}
3060impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3061 #[allow(deprecated)]
3062 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3063 where
3064 D: serde::Deserializer<'de>,
3065 {
3066 const FIELDS: &[&str] = &[
3067 "old_value",
3068 "oldValue",
3069 "new_value",
3070 "newValue",
3071 "epochs",
3072 ];
3073
3074 #[allow(clippy::enum_variant_names)]
3075 enum GeneratedField {
3076 OldValue,
3077 NewValue,
3078 Epochs,
3079 }
3080 impl<'de> serde::Deserialize<'de> for GeneratedField {
3081 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3082 where
3083 D: serde::Deserializer<'de>,
3084 {
3085 struct GeneratedVisitor;
3086
3087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3088 type Value = GeneratedField;
3089
3090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3091 write!(formatter, "expected one of: {:?}", &FIELDS)
3092 }
3093
3094 #[allow(unused_variables)]
3095 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3096 where
3097 E: serde::de::Error,
3098 {
3099 match value {
3100 "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3101 "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3102 "epochs" => Ok(GeneratedField::Epochs),
3103 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3104 }
3105 }
3106 }
3107 deserializer.deserialize_identifier(GeneratedVisitor)
3108 }
3109 }
3110 struct GeneratedVisitor;
3111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3112 type Value = EpochNewChangeLog;
3113
3114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3115 formatter.write_str("struct hummock.EpochNewChangeLog")
3116 }
3117
3118 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3119 where
3120 V: serde::de::MapAccess<'de>,
3121 {
3122 let mut old_value__ = None;
3123 let mut new_value__ = None;
3124 let mut epochs__ = None;
3125 while let Some(k) = map_.next_key()? {
3126 match k {
3127 GeneratedField::OldValue => {
3128 if old_value__.is_some() {
3129 return Err(serde::de::Error::duplicate_field("oldValue"));
3130 }
3131 old_value__ = Some(map_.next_value()?);
3132 }
3133 GeneratedField::NewValue => {
3134 if new_value__.is_some() {
3135 return Err(serde::de::Error::duplicate_field("newValue"));
3136 }
3137 new_value__ = Some(map_.next_value()?);
3138 }
3139 GeneratedField::Epochs => {
3140 if epochs__.is_some() {
3141 return Err(serde::de::Error::duplicate_field("epochs"));
3142 }
3143 epochs__ =
3144 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3145 .into_iter().map(|x| x.0).collect())
3146 ;
3147 }
3148 }
3149 }
3150 Ok(EpochNewChangeLog {
3151 old_value: old_value__.unwrap_or_default(),
3152 new_value: new_value__.unwrap_or_default(),
3153 epochs: epochs__.unwrap_or_default(),
3154 })
3155 }
3156 }
3157 deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3158 }
3159}
3160impl serde::Serialize for FlatIndex {
3161 #[allow(deprecated)]
3162 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3163 where
3164 S: serde::Serializer,
3165 {
3166 use serde::ser::SerializeStruct;
3167 let mut len = 0;
3168 if self.config.is_some() {
3169 len += 1;
3170 }
3171 if !self.vector_files.is_empty() {
3172 len += 1;
3173 }
3174 if self.next_vector_id != 0 {
3175 len += 1;
3176 }
3177 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3178 if let Some(v) = self.config.as_ref() {
3179 struct_ser.serialize_field("config", v)?;
3180 }
3181 if !self.vector_files.is_empty() {
3182 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3183 }
3184 if self.next_vector_id != 0 {
3185 #[allow(clippy::needless_borrow)]
3186 #[allow(clippy::needless_borrows_for_generic_args)]
3187 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3188 }
3189 struct_ser.end()
3190 }
3191}
3192impl<'de> serde::Deserialize<'de> for FlatIndex {
3193 #[allow(deprecated)]
3194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3195 where
3196 D: serde::Deserializer<'de>,
3197 {
3198 const FIELDS: &[&str] = &[
3199 "config",
3200 "vector_files",
3201 "vectorFiles",
3202 "next_vector_id",
3203 "nextVectorId",
3204 ];
3205
3206 #[allow(clippy::enum_variant_names)]
3207 enum GeneratedField {
3208 Config,
3209 VectorFiles,
3210 NextVectorId,
3211 }
3212 impl<'de> serde::Deserialize<'de> for GeneratedField {
3213 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3214 where
3215 D: serde::Deserializer<'de>,
3216 {
3217 struct GeneratedVisitor;
3218
3219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3220 type Value = GeneratedField;
3221
3222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3223 write!(formatter, "expected one of: {:?}", &FIELDS)
3224 }
3225
3226 #[allow(unused_variables)]
3227 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3228 where
3229 E: serde::de::Error,
3230 {
3231 match value {
3232 "config" => Ok(GeneratedField::Config),
3233 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3234 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3235 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3236 }
3237 }
3238 }
3239 deserializer.deserialize_identifier(GeneratedVisitor)
3240 }
3241 }
3242 struct GeneratedVisitor;
3243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3244 type Value = FlatIndex;
3245
3246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3247 formatter.write_str("struct hummock.FlatIndex")
3248 }
3249
3250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3251 where
3252 V: serde::de::MapAccess<'de>,
3253 {
3254 let mut config__ = None;
3255 let mut vector_files__ = None;
3256 let mut next_vector_id__ = None;
3257 while let Some(k) = map_.next_key()? {
3258 match k {
3259 GeneratedField::Config => {
3260 if config__.is_some() {
3261 return Err(serde::de::Error::duplicate_field("config"));
3262 }
3263 config__ = map_.next_value()?;
3264 }
3265 GeneratedField::VectorFiles => {
3266 if vector_files__.is_some() {
3267 return Err(serde::de::Error::duplicate_field("vectorFiles"));
3268 }
3269 vector_files__ = Some(map_.next_value()?);
3270 }
3271 GeneratedField::NextVectorId => {
3272 if next_vector_id__.is_some() {
3273 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3274 }
3275 next_vector_id__ =
3276 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3277 ;
3278 }
3279 }
3280 }
3281 Ok(FlatIndex {
3282 config: config__,
3283 vector_files: vector_files__.unwrap_or_default(),
3284 next_vector_id: next_vector_id__.unwrap_or_default(),
3285 })
3286 }
3287 }
3288 deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3289 }
3290}
3291impl serde::Serialize for FlatIndexAdd {
3292 #[allow(deprecated)]
3293 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3294 where
3295 S: serde::Serializer,
3296 {
3297 use serde::ser::SerializeStruct;
3298 let mut len = 0;
3299 if !self.added_vector_files.is_empty() {
3300 len += 1;
3301 }
3302 if self.next_vector_id != 0 {
3303 len += 1;
3304 }
3305 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3306 if !self.added_vector_files.is_empty() {
3307 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3308 }
3309 if self.next_vector_id != 0 {
3310 #[allow(clippy::needless_borrow)]
3311 #[allow(clippy::needless_borrows_for_generic_args)]
3312 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3313 }
3314 struct_ser.end()
3315 }
3316}
3317impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3318 #[allow(deprecated)]
3319 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3320 where
3321 D: serde::Deserializer<'de>,
3322 {
3323 const FIELDS: &[&str] = &[
3324 "added_vector_files",
3325 "addedVectorFiles",
3326 "next_vector_id",
3327 "nextVectorId",
3328 ];
3329
3330 #[allow(clippy::enum_variant_names)]
3331 enum GeneratedField {
3332 AddedVectorFiles,
3333 NextVectorId,
3334 }
3335 impl<'de> serde::Deserialize<'de> for GeneratedField {
3336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3337 where
3338 D: serde::Deserializer<'de>,
3339 {
3340 struct GeneratedVisitor;
3341
3342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3343 type Value = GeneratedField;
3344
3345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3346 write!(formatter, "expected one of: {:?}", &FIELDS)
3347 }
3348
3349 #[allow(unused_variables)]
3350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3351 where
3352 E: serde::de::Error,
3353 {
3354 match value {
3355 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3356 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3357 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3358 }
3359 }
3360 }
3361 deserializer.deserialize_identifier(GeneratedVisitor)
3362 }
3363 }
3364 struct GeneratedVisitor;
3365 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3366 type Value = FlatIndexAdd;
3367
3368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3369 formatter.write_str("struct hummock.FlatIndexAdd")
3370 }
3371
3372 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3373 where
3374 V: serde::de::MapAccess<'de>,
3375 {
3376 let mut added_vector_files__ = None;
3377 let mut next_vector_id__ = None;
3378 while let Some(k) = map_.next_key()? {
3379 match k {
3380 GeneratedField::AddedVectorFiles => {
3381 if added_vector_files__.is_some() {
3382 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3383 }
3384 added_vector_files__ = Some(map_.next_value()?);
3385 }
3386 GeneratedField::NextVectorId => {
3387 if next_vector_id__.is_some() {
3388 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3389 }
3390 next_vector_id__ =
3391 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3392 ;
3393 }
3394 }
3395 }
3396 Ok(FlatIndexAdd {
3397 added_vector_files: added_vector_files__.unwrap_or_default(),
3398 next_vector_id: next_vector_id__.unwrap_or_default(),
3399 })
3400 }
3401 }
3402 deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3403 }
3404}
3405impl serde::Serialize for FullScanTask {
3406 #[allow(deprecated)]
3407 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3408 where
3409 S: serde::Serializer,
3410 {
3411 use serde::ser::SerializeStruct;
3412 let mut len = 0;
3413 if self.sst_retention_watermark != 0 {
3414 len += 1;
3415 }
3416 if self.prefix.is_some() {
3417 len += 1;
3418 }
3419 if self.start_after.is_some() {
3420 len += 1;
3421 }
3422 if self.limit.is_some() {
3423 len += 1;
3424 }
3425 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3426 if self.sst_retention_watermark != 0 {
3427 #[allow(clippy::needless_borrow)]
3428 #[allow(clippy::needless_borrows_for_generic_args)]
3429 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3430 }
3431 if let Some(v) = self.prefix.as_ref() {
3432 struct_ser.serialize_field("prefix", v)?;
3433 }
3434 if let Some(v) = self.start_after.as_ref() {
3435 struct_ser.serialize_field("startAfter", v)?;
3436 }
3437 if let Some(v) = self.limit.as_ref() {
3438 #[allow(clippy::needless_borrow)]
3439 #[allow(clippy::needless_borrows_for_generic_args)]
3440 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3441 }
3442 struct_ser.end()
3443 }
3444}
3445impl<'de> serde::Deserialize<'de> for FullScanTask {
3446 #[allow(deprecated)]
3447 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3448 where
3449 D: serde::Deserializer<'de>,
3450 {
3451 const FIELDS: &[&str] = &[
3452 "sst_retention_watermark",
3453 "sstRetentionWatermark",
3454 "prefix",
3455 "start_after",
3456 "startAfter",
3457 "limit",
3458 ];
3459
3460 #[allow(clippy::enum_variant_names)]
3461 enum GeneratedField {
3462 SstRetentionWatermark,
3463 Prefix,
3464 StartAfter,
3465 Limit,
3466 }
3467 impl<'de> serde::Deserialize<'de> for GeneratedField {
3468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3469 where
3470 D: serde::Deserializer<'de>,
3471 {
3472 struct GeneratedVisitor;
3473
3474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3475 type Value = GeneratedField;
3476
3477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3478 write!(formatter, "expected one of: {:?}", &FIELDS)
3479 }
3480
3481 #[allow(unused_variables)]
3482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3483 where
3484 E: serde::de::Error,
3485 {
3486 match value {
3487 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3488 "prefix" => Ok(GeneratedField::Prefix),
3489 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3490 "limit" => Ok(GeneratedField::Limit),
3491 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3492 }
3493 }
3494 }
3495 deserializer.deserialize_identifier(GeneratedVisitor)
3496 }
3497 }
3498 struct GeneratedVisitor;
3499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3500 type Value = FullScanTask;
3501
3502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3503 formatter.write_str("struct hummock.FullScanTask")
3504 }
3505
3506 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3507 where
3508 V: serde::de::MapAccess<'de>,
3509 {
3510 let mut sst_retention_watermark__ = None;
3511 let mut prefix__ = None;
3512 let mut start_after__ = None;
3513 let mut limit__ = None;
3514 while let Some(k) = map_.next_key()? {
3515 match k {
3516 GeneratedField::SstRetentionWatermark => {
3517 if sst_retention_watermark__.is_some() {
3518 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3519 }
3520 sst_retention_watermark__ =
3521 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3522 ;
3523 }
3524 GeneratedField::Prefix => {
3525 if prefix__.is_some() {
3526 return Err(serde::de::Error::duplicate_field("prefix"));
3527 }
3528 prefix__ = map_.next_value()?;
3529 }
3530 GeneratedField::StartAfter => {
3531 if start_after__.is_some() {
3532 return Err(serde::de::Error::duplicate_field("startAfter"));
3533 }
3534 start_after__ = map_.next_value()?;
3535 }
3536 GeneratedField::Limit => {
3537 if limit__.is_some() {
3538 return Err(serde::de::Error::duplicate_field("limit"));
3539 }
3540 limit__ =
3541 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3542 ;
3543 }
3544 }
3545 }
3546 Ok(FullScanTask {
3547 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3548 prefix: prefix__,
3549 start_after: start_after__,
3550 limit: limit__,
3551 })
3552 }
3553 }
3554 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3555 }
3556}
3557impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3558 #[allow(deprecated)]
3559 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3560 where
3561 S: serde::Serializer,
3562 {
3563 use serde::ser::SerializeStruct;
3564 let len = 0;
3565 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3566 struct_ser.end()
3567 }
3568}
3569impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3570 #[allow(deprecated)]
3571 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3572 where
3573 D: serde::Deserializer<'de>,
3574 {
3575 const FIELDS: &[&str] = &[
3576 ];
3577
3578 #[allow(clippy::enum_variant_names)]
3579 enum GeneratedField {
3580 }
3581 impl<'de> serde::Deserialize<'de> for GeneratedField {
3582 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3583 where
3584 D: serde::Deserializer<'de>,
3585 {
3586 struct GeneratedVisitor;
3587
3588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3589 type Value = GeneratedField;
3590
3591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3592 write!(formatter, "expected one of: {:?}", &FIELDS)
3593 }
3594
3595 #[allow(unused_variables)]
3596 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3597 where
3598 E: serde::de::Error,
3599 {
3600 Err(serde::de::Error::unknown_field(value, FIELDS))
3601 }
3602 }
3603 deserializer.deserialize_identifier(GeneratedVisitor)
3604 }
3605 }
3606 struct GeneratedVisitor;
3607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3608 type Value = GetAssignedCompactTaskNumRequest;
3609
3610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3611 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3612 }
3613
3614 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3615 where
3616 V: serde::de::MapAccess<'de>,
3617 {
3618 while map_.next_key::<GeneratedField>()?.is_some() {
3619 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3620 }
3621 Ok(GetAssignedCompactTaskNumRequest {
3622 })
3623 }
3624 }
3625 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3626 }
3627}
3628impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3629 #[allow(deprecated)]
3630 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3631 where
3632 S: serde::Serializer,
3633 {
3634 use serde::ser::SerializeStruct;
3635 let mut len = 0;
3636 if self.num_tasks != 0 {
3637 len += 1;
3638 }
3639 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3640 if self.num_tasks != 0 {
3641 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3642 }
3643 struct_ser.end()
3644 }
3645}
3646impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3647 #[allow(deprecated)]
3648 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3649 where
3650 D: serde::Deserializer<'de>,
3651 {
3652 const FIELDS: &[&str] = &[
3653 "num_tasks",
3654 "numTasks",
3655 ];
3656
3657 #[allow(clippy::enum_variant_names)]
3658 enum GeneratedField {
3659 NumTasks,
3660 }
3661 impl<'de> serde::Deserialize<'de> for GeneratedField {
3662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3663 where
3664 D: serde::Deserializer<'de>,
3665 {
3666 struct GeneratedVisitor;
3667
3668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3669 type Value = GeneratedField;
3670
3671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3672 write!(formatter, "expected one of: {:?}", &FIELDS)
3673 }
3674
3675 #[allow(unused_variables)]
3676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3677 where
3678 E: serde::de::Error,
3679 {
3680 match value {
3681 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3682 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3683 }
3684 }
3685 }
3686 deserializer.deserialize_identifier(GeneratedVisitor)
3687 }
3688 }
3689 struct GeneratedVisitor;
3690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3691 type Value = GetAssignedCompactTaskNumResponse;
3692
3693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3694 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3695 }
3696
3697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3698 where
3699 V: serde::de::MapAccess<'de>,
3700 {
3701 let mut num_tasks__ = None;
3702 while let Some(k) = map_.next_key()? {
3703 match k {
3704 GeneratedField::NumTasks => {
3705 if num_tasks__.is_some() {
3706 return Err(serde::de::Error::duplicate_field("numTasks"));
3707 }
3708 num_tasks__ =
3709 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3710 ;
3711 }
3712 }
3713 }
3714 Ok(GetAssignedCompactTaskNumResponse {
3715 num_tasks: num_tasks__.unwrap_or_default(),
3716 })
3717 }
3718 }
3719 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3720 }
3721}
3722impl serde::Serialize for GetCompactionScoreRequest {
3723 #[allow(deprecated)]
3724 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3725 where
3726 S: serde::Serializer,
3727 {
3728 use serde::ser::SerializeStruct;
3729 let mut len = 0;
3730 if self.compaction_group_id != 0 {
3731 len += 1;
3732 }
3733 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3734 if self.compaction_group_id != 0 {
3735 #[allow(clippy::needless_borrow)]
3736 #[allow(clippy::needless_borrows_for_generic_args)]
3737 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3738 }
3739 struct_ser.end()
3740 }
3741}
3742impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3743 #[allow(deprecated)]
3744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3745 where
3746 D: serde::Deserializer<'de>,
3747 {
3748 const FIELDS: &[&str] = &[
3749 "compaction_group_id",
3750 "compactionGroupId",
3751 ];
3752
3753 #[allow(clippy::enum_variant_names)]
3754 enum GeneratedField {
3755 CompactionGroupId,
3756 }
3757 impl<'de> serde::Deserialize<'de> for GeneratedField {
3758 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3759 where
3760 D: serde::Deserializer<'de>,
3761 {
3762 struct GeneratedVisitor;
3763
3764 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3765 type Value = GeneratedField;
3766
3767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3768 write!(formatter, "expected one of: {:?}", &FIELDS)
3769 }
3770
3771 #[allow(unused_variables)]
3772 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3773 where
3774 E: serde::de::Error,
3775 {
3776 match value {
3777 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3779 }
3780 }
3781 }
3782 deserializer.deserialize_identifier(GeneratedVisitor)
3783 }
3784 }
3785 struct GeneratedVisitor;
3786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3787 type Value = GetCompactionScoreRequest;
3788
3789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3790 formatter.write_str("struct hummock.GetCompactionScoreRequest")
3791 }
3792
3793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3794 where
3795 V: serde::de::MapAccess<'de>,
3796 {
3797 let mut compaction_group_id__ = None;
3798 while let Some(k) = map_.next_key()? {
3799 match k {
3800 GeneratedField::CompactionGroupId => {
3801 if compaction_group_id__.is_some() {
3802 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3803 }
3804 compaction_group_id__ =
3805 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3806 ;
3807 }
3808 }
3809 }
3810 Ok(GetCompactionScoreRequest {
3811 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3812 })
3813 }
3814 }
3815 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
3816 }
3817}
3818impl serde::Serialize for GetCompactionScoreResponse {
3819 #[allow(deprecated)]
3820 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3821 where
3822 S: serde::Serializer,
3823 {
3824 use serde::ser::SerializeStruct;
3825 let mut len = 0;
3826 if self.compaction_group_id != 0 {
3827 len += 1;
3828 }
3829 if !self.scores.is_empty() {
3830 len += 1;
3831 }
3832 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
3833 if self.compaction_group_id != 0 {
3834 #[allow(clippy::needless_borrow)]
3835 #[allow(clippy::needless_borrows_for_generic_args)]
3836 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3837 }
3838 if !self.scores.is_empty() {
3839 struct_ser.serialize_field("scores", &self.scores)?;
3840 }
3841 struct_ser.end()
3842 }
3843}
3844impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
3845 #[allow(deprecated)]
3846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3847 where
3848 D: serde::Deserializer<'de>,
3849 {
3850 const FIELDS: &[&str] = &[
3851 "compaction_group_id",
3852 "compactionGroupId",
3853 "scores",
3854 ];
3855
3856 #[allow(clippy::enum_variant_names)]
3857 enum GeneratedField {
3858 CompactionGroupId,
3859 Scores,
3860 }
3861 impl<'de> serde::Deserialize<'de> for GeneratedField {
3862 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3863 where
3864 D: serde::Deserializer<'de>,
3865 {
3866 struct GeneratedVisitor;
3867
3868 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3869 type Value = GeneratedField;
3870
3871 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3872 write!(formatter, "expected one of: {:?}", &FIELDS)
3873 }
3874
3875 #[allow(unused_variables)]
3876 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3877 where
3878 E: serde::de::Error,
3879 {
3880 match value {
3881 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3882 "scores" => Ok(GeneratedField::Scores),
3883 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3884 }
3885 }
3886 }
3887 deserializer.deserialize_identifier(GeneratedVisitor)
3888 }
3889 }
3890 struct GeneratedVisitor;
3891 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3892 type Value = GetCompactionScoreResponse;
3893
3894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3895 formatter.write_str("struct hummock.GetCompactionScoreResponse")
3896 }
3897
3898 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
3899 where
3900 V: serde::de::MapAccess<'de>,
3901 {
3902 let mut compaction_group_id__ = None;
3903 let mut scores__ = None;
3904 while let Some(k) = map_.next_key()? {
3905 match k {
3906 GeneratedField::CompactionGroupId => {
3907 if compaction_group_id__.is_some() {
3908 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3909 }
3910 compaction_group_id__ =
3911 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3912 ;
3913 }
3914 GeneratedField::Scores => {
3915 if scores__.is_some() {
3916 return Err(serde::de::Error::duplicate_field("scores"));
3917 }
3918 scores__ = Some(map_.next_value()?);
3919 }
3920 }
3921 }
3922 Ok(GetCompactionScoreResponse {
3923 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3924 scores: scores__.unwrap_or_default(),
3925 })
3926 }
3927 }
3928 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
3929 }
3930}
3931impl serde::Serialize for get_compaction_score_response::PickerInfo {
3932 #[allow(deprecated)]
3933 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3934 where
3935 S: serde::Serializer,
3936 {
3937 use serde::ser::SerializeStruct;
3938 let mut len = 0;
3939 if self.score != 0 {
3940 len += 1;
3941 }
3942 if self.select_level != 0 {
3943 len += 1;
3944 }
3945 if self.target_level != 0 {
3946 len += 1;
3947 }
3948 if !self.picker_type.is_empty() {
3949 len += 1;
3950 }
3951 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
3952 if self.score != 0 {
3953 #[allow(clippy::needless_borrow)]
3954 #[allow(clippy::needless_borrows_for_generic_args)]
3955 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
3956 }
3957 if self.select_level != 0 {
3958 #[allow(clippy::needless_borrow)]
3959 #[allow(clippy::needless_borrows_for_generic_args)]
3960 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
3961 }
3962 if self.target_level != 0 {
3963 #[allow(clippy::needless_borrow)]
3964 #[allow(clippy::needless_borrows_for_generic_args)]
3965 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
3966 }
3967 if !self.picker_type.is_empty() {
3968 struct_ser.serialize_field("pickerType", &self.picker_type)?;
3969 }
3970 struct_ser.end()
3971 }
3972}
3973impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
3974 #[allow(deprecated)]
3975 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3976 where
3977 D: serde::Deserializer<'de>,
3978 {
3979 const FIELDS: &[&str] = &[
3980 "score",
3981 "select_level",
3982 "selectLevel",
3983 "target_level",
3984 "targetLevel",
3985 "picker_type",
3986 "pickerType",
3987 ];
3988
3989 #[allow(clippy::enum_variant_names)]
3990 enum GeneratedField {
3991 Score,
3992 SelectLevel,
3993 TargetLevel,
3994 PickerType,
3995 }
3996 impl<'de> serde::Deserialize<'de> for GeneratedField {
3997 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3998 where
3999 D: serde::Deserializer<'de>,
4000 {
4001 struct GeneratedVisitor;
4002
4003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4004 type Value = GeneratedField;
4005
4006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4007 write!(formatter, "expected one of: {:?}", &FIELDS)
4008 }
4009
4010 #[allow(unused_variables)]
4011 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4012 where
4013 E: serde::de::Error,
4014 {
4015 match value {
4016 "score" => Ok(GeneratedField::Score),
4017 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4018 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4019 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4020 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4021 }
4022 }
4023 }
4024 deserializer.deserialize_identifier(GeneratedVisitor)
4025 }
4026 }
4027 struct GeneratedVisitor;
4028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4029 type Value = get_compaction_score_response::PickerInfo;
4030
4031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4032 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4033 }
4034
4035 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4036 where
4037 V: serde::de::MapAccess<'de>,
4038 {
4039 let mut score__ = None;
4040 let mut select_level__ = None;
4041 let mut target_level__ = None;
4042 let mut picker_type__ = None;
4043 while let Some(k) = map_.next_key()? {
4044 match k {
4045 GeneratedField::Score => {
4046 if score__.is_some() {
4047 return Err(serde::de::Error::duplicate_field("score"));
4048 }
4049 score__ =
4050 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4051 ;
4052 }
4053 GeneratedField::SelectLevel => {
4054 if select_level__.is_some() {
4055 return Err(serde::de::Error::duplicate_field("selectLevel"));
4056 }
4057 select_level__ =
4058 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4059 ;
4060 }
4061 GeneratedField::TargetLevel => {
4062 if target_level__.is_some() {
4063 return Err(serde::de::Error::duplicate_field("targetLevel"));
4064 }
4065 target_level__ =
4066 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4067 ;
4068 }
4069 GeneratedField::PickerType => {
4070 if picker_type__.is_some() {
4071 return Err(serde::de::Error::duplicate_field("pickerType"));
4072 }
4073 picker_type__ = Some(map_.next_value()?);
4074 }
4075 }
4076 }
4077 Ok(get_compaction_score_response::PickerInfo {
4078 score: score__.unwrap_or_default(),
4079 select_level: select_level__.unwrap_or_default(),
4080 target_level: target_level__.unwrap_or_default(),
4081 picker_type: picker_type__.unwrap_or_default(),
4082 })
4083 }
4084 }
4085 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4086 }
4087}
4088impl serde::Serialize for GetCurrentVersionRequest {
4089 #[allow(deprecated)]
4090 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4091 where
4092 S: serde::Serializer,
4093 {
4094 use serde::ser::SerializeStruct;
4095 let len = 0;
4096 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4097 struct_ser.end()
4098 }
4099}
4100impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4101 #[allow(deprecated)]
4102 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4103 where
4104 D: serde::Deserializer<'de>,
4105 {
4106 const FIELDS: &[&str] = &[
4107 ];
4108
4109 #[allow(clippy::enum_variant_names)]
4110 enum GeneratedField {
4111 }
4112 impl<'de> serde::Deserialize<'de> for GeneratedField {
4113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4114 where
4115 D: serde::Deserializer<'de>,
4116 {
4117 struct GeneratedVisitor;
4118
4119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4120 type Value = GeneratedField;
4121
4122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4123 write!(formatter, "expected one of: {:?}", &FIELDS)
4124 }
4125
4126 #[allow(unused_variables)]
4127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4128 where
4129 E: serde::de::Error,
4130 {
4131 Err(serde::de::Error::unknown_field(value, FIELDS))
4132 }
4133 }
4134 deserializer.deserialize_identifier(GeneratedVisitor)
4135 }
4136 }
4137 struct GeneratedVisitor;
4138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4139 type Value = GetCurrentVersionRequest;
4140
4141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4142 formatter.write_str("struct hummock.GetCurrentVersionRequest")
4143 }
4144
4145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4146 where
4147 V: serde::de::MapAccess<'de>,
4148 {
4149 while map_.next_key::<GeneratedField>()?.is_some() {
4150 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4151 }
4152 Ok(GetCurrentVersionRequest {
4153 })
4154 }
4155 }
4156 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4157 }
4158}
4159impl serde::Serialize for GetCurrentVersionResponse {
4160 #[allow(deprecated)]
4161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4162 where
4163 S: serde::Serializer,
4164 {
4165 use serde::ser::SerializeStruct;
4166 let mut len = 0;
4167 if self.status.is_some() {
4168 len += 1;
4169 }
4170 if self.current_version.is_some() {
4171 len += 1;
4172 }
4173 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4174 if let Some(v) = self.status.as_ref() {
4175 struct_ser.serialize_field("status", v)?;
4176 }
4177 if let Some(v) = self.current_version.as_ref() {
4178 struct_ser.serialize_field("currentVersion", v)?;
4179 }
4180 struct_ser.end()
4181 }
4182}
4183impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4184 #[allow(deprecated)]
4185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4186 where
4187 D: serde::Deserializer<'de>,
4188 {
4189 const FIELDS: &[&str] = &[
4190 "status",
4191 "current_version",
4192 "currentVersion",
4193 ];
4194
4195 #[allow(clippy::enum_variant_names)]
4196 enum GeneratedField {
4197 Status,
4198 CurrentVersion,
4199 }
4200 impl<'de> serde::Deserialize<'de> for GeneratedField {
4201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4202 where
4203 D: serde::Deserializer<'de>,
4204 {
4205 struct GeneratedVisitor;
4206
4207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4208 type Value = GeneratedField;
4209
4210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4211 write!(formatter, "expected one of: {:?}", &FIELDS)
4212 }
4213
4214 #[allow(unused_variables)]
4215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4216 where
4217 E: serde::de::Error,
4218 {
4219 match value {
4220 "status" => Ok(GeneratedField::Status),
4221 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4222 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4223 }
4224 }
4225 }
4226 deserializer.deserialize_identifier(GeneratedVisitor)
4227 }
4228 }
4229 struct GeneratedVisitor;
4230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4231 type Value = GetCurrentVersionResponse;
4232
4233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4234 formatter.write_str("struct hummock.GetCurrentVersionResponse")
4235 }
4236
4237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4238 where
4239 V: serde::de::MapAccess<'de>,
4240 {
4241 let mut status__ = None;
4242 let mut current_version__ = None;
4243 while let Some(k) = map_.next_key()? {
4244 match k {
4245 GeneratedField::Status => {
4246 if status__.is_some() {
4247 return Err(serde::de::Error::duplicate_field("status"));
4248 }
4249 status__ = map_.next_value()?;
4250 }
4251 GeneratedField::CurrentVersion => {
4252 if current_version__.is_some() {
4253 return Err(serde::de::Error::duplicate_field("currentVersion"));
4254 }
4255 current_version__ = map_.next_value()?;
4256 }
4257 }
4258 }
4259 Ok(GetCurrentVersionResponse {
4260 status: status__,
4261 current_version: current_version__,
4262 })
4263 }
4264 }
4265 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4266 }
4267}
4268impl serde::Serialize for GetNewObjectIdsRequest {
4269 #[allow(deprecated)]
4270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4271 where
4272 S: serde::Serializer,
4273 {
4274 use serde::ser::SerializeStruct;
4275 let mut len = 0;
4276 if self.number != 0 {
4277 len += 1;
4278 }
4279 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4280 if self.number != 0 {
4281 struct_ser.serialize_field("number", &self.number)?;
4282 }
4283 struct_ser.end()
4284 }
4285}
4286impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4287 #[allow(deprecated)]
4288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4289 where
4290 D: serde::Deserializer<'de>,
4291 {
4292 const FIELDS: &[&str] = &[
4293 "number",
4294 ];
4295
4296 #[allow(clippy::enum_variant_names)]
4297 enum GeneratedField {
4298 Number,
4299 }
4300 impl<'de> serde::Deserialize<'de> for GeneratedField {
4301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4302 where
4303 D: serde::Deserializer<'de>,
4304 {
4305 struct GeneratedVisitor;
4306
4307 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4308 type Value = GeneratedField;
4309
4310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4311 write!(formatter, "expected one of: {:?}", &FIELDS)
4312 }
4313
4314 #[allow(unused_variables)]
4315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4316 where
4317 E: serde::de::Error,
4318 {
4319 match value {
4320 "number" => Ok(GeneratedField::Number),
4321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4322 }
4323 }
4324 }
4325 deserializer.deserialize_identifier(GeneratedVisitor)
4326 }
4327 }
4328 struct GeneratedVisitor;
4329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4330 type Value = GetNewObjectIdsRequest;
4331
4332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4333 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4334 }
4335
4336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4337 where
4338 V: serde::de::MapAccess<'de>,
4339 {
4340 let mut number__ = None;
4341 while let Some(k) = map_.next_key()? {
4342 match k {
4343 GeneratedField::Number => {
4344 if number__.is_some() {
4345 return Err(serde::de::Error::duplicate_field("number"));
4346 }
4347 number__ =
4348 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4349 ;
4350 }
4351 }
4352 }
4353 Ok(GetNewObjectIdsRequest {
4354 number: number__.unwrap_or_default(),
4355 })
4356 }
4357 }
4358 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4359 }
4360}
4361impl serde::Serialize for GetNewObjectIdsResponse {
4362 #[allow(deprecated)]
4363 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4364 where
4365 S: serde::Serializer,
4366 {
4367 use serde::ser::SerializeStruct;
4368 let mut len = 0;
4369 if self.status.is_some() {
4370 len += 1;
4371 }
4372 if self.start_id != 0 {
4373 len += 1;
4374 }
4375 if self.end_id != 0 {
4376 len += 1;
4377 }
4378 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4379 if let Some(v) = self.status.as_ref() {
4380 struct_ser.serialize_field("status", v)?;
4381 }
4382 if self.start_id != 0 {
4383 #[allow(clippy::needless_borrow)]
4384 #[allow(clippy::needless_borrows_for_generic_args)]
4385 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4386 }
4387 if self.end_id != 0 {
4388 #[allow(clippy::needless_borrow)]
4389 #[allow(clippy::needless_borrows_for_generic_args)]
4390 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4391 }
4392 struct_ser.end()
4393 }
4394}
4395impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4396 #[allow(deprecated)]
4397 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4398 where
4399 D: serde::Deserializer<'de>,
4400 {
4401 const FIELDS: &[&str] = &[
4402 "status",
4403 "start_id",
4404 "startId",
4405 "end_id",
4406 "endId",
4407 ];
4408
4409 #[allow(clippy::enum_variant_names)]
4410 enum GeneratedField {
4411 Status,
4412 StartId,
4413 EndId,
4414 }
4415 impl<'de> serde::Deserialize<'de> for GeneratedField {
4416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4417 where
4418 D: serde::Deserializer<'de>,
4419 {
4420 struct GeneratedVisitor;
4421
4422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4423 type Value = GeneratedField;
4424
4425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4426 write!(formatter, "expected one of: {:?}", &FIELDS)
4427 }
4428
4429 #[allow(unused_variables)]
4430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4431 where
4432 E: serde::de::Error,
4433 {
4434 match value {
4435 "status" => Ok(GeneratedField::Status),
4436 "startId" | "start_id" => Ok(GeneratedField::StartId),
4437 "endId" | "end_id" => Ok(GeneratedField::EndId),
4438 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4439 }
4440 }
4441 }
4442 deserializer.deserialize_identifier(GeneratedVisitor)
4443 }
4444 }
4445 struct GeneratedVisitor;
4446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4447 type Value = GetNewObjectIdsResponse;
4448
4449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4450 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4451 }
4452
4453 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4454 where
4455 V: serde::de::MapAccess<'de>,
4456 {
4457 let mut status__ = None;
4458 let mut start_id__ = None;
4459 let mut end_id__ = None;
4460 while let Some(k) = map_.next_key()? {
4461 match k {
4462 GeneratedField::Status => {
4463 if status__.is_some() {
4464 return Err(serde::de::Error::duplicate_field("status"));
4465 }
4466 status__ = map_.next_value()?;
4467 }
4468 GeneratedField::StartId => {
4469 if start_id__.is_some() {
4470 return Err(serde::de::Error::duplicate_field("startId"));
4471 }
4472 start_id__ =
4473 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4474 ;
4475 }
4476 GeneratedField::EndId => {
4477 if end_id__.is_some() {
4478 return Err(serde::de::Error::duplicate_field("endId"));
4479 }
4480 end_id__ =
4481 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4482 ;
4483 }
4484 }
4485 }
4486 Ok(GetNewObjectIdsResponse {
4487 status: status__,
4488 start_id: start_id__.unwrap_or_default(),
4489 end_id: end_id__.unwrap_or_default(),
4490 })
4491 }
4492 }
4493 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4494 }
4495}
4496impl serde::Serialize for GetVersionByEpochRequest {
4497 #[allow(deprecated)]
4498 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4499 where
4500 S: serde::Serializer,
4501 {
4502 use serde::ser::SerializeStruct;
4503 let mut len = 0;
4504 if self.epoch != 0 {
4505 len += 1;
4506 }
4507 if self.table_id != 0 {
4508 len += 1;
4509 }
4510 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
4511 if self.epoch != 0 {
4512 #[allow(clippy::needless_borrow)]
4513 #[allow(clippy::needless_borrows_for_generic_args)]
4514 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
4515 }
4516 if self.table_id != 0 {
4517 struct_ser.serialize_field("tableId", &self.table_id)?;
4518 }
4519 struct_ser.end()
4520 }
4521}
4522impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
4523 #[allow(deprecated)]
4524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4525 where
4526 D: serde::Deserializer<'de>,
4527 {
4528 const FIELDS: &[&str] = &[
4529 "epoch",
4530 "table_id",
4531 "tableId",
4532 ];
4533
4534 #[allow(clippy::enum_variant_names)]
4535 enum GeneratedField {
4536 Epoch,
4537 TableId,
4538 }
4539 impl<'de> serde::Deserialize<'de> for GeneratedField {
4540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4541 where
4542 D: serde::Deserializer<'de>,
4543 {
4544 struct GeneratedVisitor;
4545
4546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4547 type Value = GeneratedField;
4548
4549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4550 write!(formatter, "expected one of: {:?}", &FIELDS)
4551 }
4552
4553 #[allow(unused_variables)]
4554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4555 where
4556 E: serde::de::Error,
4557 {
4558 match value {
4559 "epoch" => Ok(GeneratedField::Epoch),
4560 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4561 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4562 }
4563 }
4564 }
4565 deserializer.deserialize_identifier(GeneratedVisitor)
4566 }
4567 }
4568 struct GeneratedVisitor;
4569 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4570 type Value = GetVersionByEpochRequest;
4571
4572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4573 formatter.write_str("struct hummock.GetVersionByEpochRequest")
4574 }
4575
4576 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
4577 where
4578 V: serde::de::MapAccess<'de>,
4579 {
4580 let mut epoch__ = None;
4581 let mut table_id__ = None;
4582 while let Some(k) = map_.next_key()? {
4583 match k {
4584 GeneratedField::Epoch => {
4585 if epoch__.is_some() {
4586 return Err(serde::de::Error::duplicate_field("epoch"));
4587 }
4588 epoch__ =
4589 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4590 ;
4591 }
4592 GeneratedField::TableId => {
4593 if table_id__.is_some() {
4594 return Err(serde::de::Error::duplicate_field("tableId"));
4595 }
4596 table_id__ =
4597 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4598 ;
4599 }
4600 }
4601 }
4602 Ok(GetVersionByEpochRequest {
4603 epoch: epoch__.unwrap_or_default(),
4604 table_id: table_id__.unwrap_or_default(),
4605 })
4606 }
4607 }
4608 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
4609 }
4610}
4611impl serde::Serialize for GetVersionByEpochResponse {
4612 #[allow(deprecated)]
4613 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4614 where
4615 S: serde::Serializer,
4616 {
4617 use serde::ser::SerializeStruct;
4618 let mut len = 0;
4619 if self.version.is_some() {
4620 len += 1;
4621 }
4622 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
4623 if let Some(v) = self.version.as_ref() {
4624 struct_ser.serialize_field("version", v)?;
4625 }
4626 struct_ser.end()
4627 }
4628}
4629impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
4630 #[allow(deprecated)]
4631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4632 where
4633 D: serde::Deserializer<'de>,
4634 {
4635 const FIELDS: &[&str] = &[
4636 "version",
4637 ];
4638
4639 #[allow(clippy::enum_variant_names)]
4640 enum GeneratedField {
4641 Version,
4642 }
4643 impl<'de> serde::Deserialize<'de> for GeneratedField {
4644 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4645 where
4646 D: serde::Deserializer<'de>,
4647 {
4648 struct GeneratedVisitor;
4649
4650 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4651 type Value = GeneratedField;
4652
4653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4654 write!(formatter, "expected one of: {:?}", &FIELDS)
4655 }
4656
4657 #[allow(unused_variables)]
4658 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4659 where
4660 E: serde::de::Error,
4661 {
4662 match value {
4663 "version" => Ok(GeneratedField::Version),
4664 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4665 }
4666 }
4667 }
4668 deserializer.deserialize_identifier(GeneratedVisitor)
4669 }
4670 }
4671 struct GeneratedVisitor;
4672 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4673 type Value = GetVersionByEpochResponse;
4674
4675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4676 formatter.write_str("struct hummock.GetVersionByEpochResponse")
4677 }
4678
4679 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
4680 where
4681 V: serde::de::MapAccess<'de>,
4682 {
4683 let mut version__ = None;
4684 while let Some(k) = map_.next_key()? {
4685 match k {
4686 GeneratedField::Version => {
4687 if version__.is_some() {
4688 return Err(serde::de::Error::duplicate_field("version"));
4689 }
4690 version__ = map_.next_value()?;
4691 }
4692 }
4693 }
4694 Ok(GetVersionByEpochResponse {
4695 version: version__,
4696 })
4697 }
4698 }
4699 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
4700 }
4701}
4702impl serde::Serialize for GroupConstruct {
4703 #[allow(deprecated)]
4704 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4705 where
4706 S: serde::Serializer,
4707 {
4708 use serde::ser::SerializeStruct;
4709 let mut len = 0;
4710 if self.group_config.is_some() {
4711 len += 1;
4712 }
4713 if self.parent_group_id != 0 {
4714 len += 1;
4715 }
4716 if !self.table_ids.is_empty() {
4717 len += 1;
4718 }
4719 if self.group_id != 0 {
4720 len += 1;
4721 }
4722 if self.new_sst_start_id != 0 {
4723 len += 1;
4724 }
4725 if self.version != 0 {
4726 len += 1;
4727 }
4728 if self.split_key.is_some() {
4729 len += 1;
4730 }
4731 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
4732 if let Some(v) = self.group_config.as_ref() {
4733 struct_ser.serialize_field("groupConfig", v)?;
4734 }
4735 if self.parent_group_id != 0 {
4736 #[allow(clippy::needless_borrow)]
4737 #[allow(clippy::needless_borrows_for_generic_args)]
4738 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
4739 }
4740 if !self.table_ids.is_empty() {
4741 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4742 }
4743 if self.group_id != 0 {
4744 #[allow(clippy::needless_borrow)]
4745 #[allow(clippy::needless_borrows_for_generic_args)]
4746 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
4747 }
4748 if self.new_sst_start_id != 0 {
4749 #[allow(clippy::needless_borrow)]
4750 #[allow(clippy::needless_borrows_for_generic_args)]
4751 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
4752 }
4753 if self.version != 0 {
4754 let v = CompatibilityVersion::try_from(self.version)
4755 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4756 struct_ser.serialize_field("version", &v)?;
4757 }
4758 if let Some(v) = self.split_key.as_ref() {
4759 #[allow(clippy::needless_borrow)]
4760 #[allow(clippy::needless_borrows_for_generic_args)]
4761 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
4762 }
4763 struct_ser.end()
4764 }
4765}
4766impl<'de> serde::Deserialize<'de> for GroupConstruct {
4767 #[allow(deprecated)]
4768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4769 where
4770 D: serde::Deserializer<'de>,
4771 {
4772 const FIELDS: &[&str] = &[
4773 "group_config",
4774 "groupConfig",
4775 "parent_group_id",
4776 "parentGroupId",
4777 "table_ids",
4778 "tableIds",
4779 "group_id",
4780 "groupId",
4781 "new_sst_start_id",
4782 "newSstStartId",
4783 "version",
4784 "split_key",
4785 "splitKey",
4786 ];
4787
4788 #[allow(clippy::enum_variant_names)]
4789 enum GeneratedField {
4790 GroupConfig,
4791 ParentGroupId,
4792 TableIds,
4793 GroupId,
4794 NewSstStartId,
4795 Version,
4796 SplitKey,
4797 }
4798 impl<'de> serde::Deserialize<'de> for GeneratedField {
4799 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4800 where
4801 D: serde::Deserializer<'de>,
4802 {
4803 struct GeneratedVisitor;
4804
4805 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4806 type Value = GeneratedField;
4807
4808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4809 write!(formatter, "expected one of: {:?}", &FIELDS)
4810 }
4811
4812 #[allow(unused_variables)]
4813 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4814 where
4815 E: serde::de::Error,
4816 {
4817 match value {
4818 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
4819 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
4820 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4821 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
4822 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
4823 "version" => Ok(GeneratedField::Version),
4824 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
4825 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4826 }
4827 }
4828 }
4829 deserializer.deserialize_identifier(GeneratedVisitor)
4830 }
4831 }
4832 struct GeneratedVisitor;
4833 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4834 type Value = GroupConstruct;
4835
4836 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4837 formatter.write_str("struct hummock.GroupConstruct")
4838 }
4839
4840 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
4841 where
4842 V: serde::de::MapAccess<'de>,
4843 {
4844 let mut group_config__ = None;
4845 let mut parent_group_id__ = None;
4846 let mut table_ids__ = None;
4847 let mut group_id__ = None;
4848 let mut new_sst_start_id__ = None;
4849 let mut version__ = None;
4850 let mut split_key__ = None;
4851 while let Some(k) = map_.next_key()? {
4852 match k {
4853 GeneratedField::GroupConfig => {
4854 if group_config__.is_some() {
4855 return Err(serde::de::Error::duplicate_field("groupConfig"));
4856 }
4857 group_config__ = map_.next_value()?;
4858 }
4859 GeneratedField::ParentGroupId => {
4860 if parent_group_id__.is_some() {
4861 return Err(serde::de::Error::duplicate_field("parentGroupId"));
4862 }
4863 parent_group_id__ =
4864 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4865 ;
4866 }
4867 GeneratedField::TableIds => {
4868 if table_ids__.is_some() {
4869 return Err(serde::de::Error::duplicate_field("tableIds"));
4870 }
4871 table_ids__ =
4872 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4873 .into_iter().map(|x| x.0).collect())
4874 ;
4875 }
4876 GeneratedField::GroupId => {
4877 if group_id__.is_some() {
4878 return Err(serde::de::Error::duplicate_field("groupId"));
4879 }
4880 group_id__ =
4881 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4882 ;
4883 }
4884 GeneratedField::NewSstStartId => {
4885 if new_sst_start_id__.is_some() {
4886 return Err(serde::de::Error::duplicate_field("newSstStartId"));
4887 }
4888 new_sst_start_id__ =
4889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4890 ;
4891 }
4892 GeneratedField::Version => {
4893 if version__.is_some() {
4894 return Err(serde::de::Error::duplicate_field("version"));
4895 }
4896 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
4897 }
4898 GeneratedField::SplitKey => {
4899 if split_key__.is_some() {
4900 return Err(serde::de::Error::duplicate_field("splitKey"));
4901 }
4902 split_key__ =
4903 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
4904 ;
4905 }
4906 }
4907 }
4908 Ok(GroupConstruct {
4909 group_config: group_config__,
4910 parent_group_id: parent_group_id__.unwrap_or_default(),
4911 table_ids: table_ids__.unwrap_or_default(),
4912 group_id: group_id__.unwrap_or_default(),
4913 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
4914 version: version__.unwrap_or_default(),
4915 split_key: split_key__,
4916 })
4917 }
4918 }
4919 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
4920 }
4921}
4922impl serde::Serialize for GroupDelta {
4923 #[allow(deprecated)]
4924 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4925 where
4926 S: serde::Serializer,
4927 {
4928 use serde::ser::SerializeStruct;
4929 let mut len = 0;
4930 if self.delta_type.is_some() {
4931 len += 1;
4932 }
4933 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
4934 if let Some(v) = self.delta_type.as_ref() {
4935 match v {
4936 group_delta::DeltaType::IntraLevel(v) => {
4937 struct_ser.serialize_field("intraLevel", v)?;
4938 }
4939 group_delta::DeltaType::GroupConstruct(v) => {
4940 struct_ser.serialize_field("groupConstruct", v)?;
4941 }
4942 group_delta::DeltaType::GroupDestroy(v) => {
4943 struct_ser.serialize_field("groupDestroy", v)?;
4944 }
4945 group_delta::DeltaType::GroupMerge(v) => {
4946 struct_ser.serialize_field("groupMerge", v)?;
4947 }
4948 group_delta::DeltaType::NewL0SubLevel(v) => {
4949 struct_ser.serialize_field("newL0SubLevel", v)?;
4950 }
4951 group_delta::DeltaType::TruncateTables(v) => {
4952 struct_ser.serialize_field("truncateTables", v)?;
4953 }
4954 }
4955 }
4956 struct_ser.end()
4957 }
4958}
4959impl<'de> serde::Deserialize<'de> for GroupDelta {
4960 #[allow(deprecated)]
4961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4962 where
4963 D: serde::Deserializer<'de>,
4964 {
4965 const FIELDS: &[&str] = &[
4966 "intra_level",
4967 "intraLevel",
4968 "group_construct",
4969 "groupConstruct",
4970 "group_destroy",
4971 "groupDestroy",
4972 "group_merge",
4973 "groupMerge",
4974 "new_l0_sub_level",
4975 "newL0SubLevel",
4976 "truncate_tables",
4977 "truncateTables",
4978 ];
4979
4980 #[allow(clippy::enum_variant_names)]
4981 enum GeneratedField {
4982 IntraLevel,
4983 GroupConstruct,
4984 GroupDestroy,
4985 GroupMerge,
4986 NewL0SubLevel,
4987 TruncateTables,
4988 }
4989 impl<'de> serde::Deserialize<'de> for GeneratedField {
4990 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4991 where
4992 D: serde::Deserializer<'de>,
4993 {
4994 struct GeneratedVisitor;
4995
4996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4997 type Value = GeneratedField;
4998
4999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5000 write!(formatter, "expected one of: {:?}", &FIELDS)
5001 }
5002
5003 #[allow(unused_variables)]
5004 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5005 where
5006 E: serde::de::Error,
5007 {
5008 match value {
5009 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5010 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5011 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5012 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5013 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5014 "truncateTables" | "truncate_tables" => Ok(GeneratedField::TruncateTables),
5015 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5016 }
5017 }
5018 }
5019 deserializer.deserialize_identifier(GeneratedVisitor)
5020 }
5021 }
5022 struct GeneratedVisitor;
5023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5024 type Value = GroupDelta;
5025
5026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5027 formatter.write_str("struct hummock.GroupDelta")
5028 }
5029
5030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5031 where
5032 V: serde::de::MapAccess<'de>,
5033 {
5034 let mut delta_type__ = None;
5035 while let Some(k) = map_.next_key()? {
5036 match k {
5037 GeneratedField::IntraLevel => {
5038 if delta_type__.is_some() {
5039 return Err(serde::de::Error::duplicate_field("intraLevel"));
5040 }
5041 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5042;
5043 }
5044 GeneratedField::GroupConstruct => {
5045 if delta_type__.is_some() {
5046 return Err(serde::de::Error::duplicate_field("groupConstruct"));
5047 }
5048 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5049;
5050 }
5051 GeneratedField::GroupDestroy => {
5052 if delta_type__.is_some() {
5053 return Err(serde::de::Error::duplicate_field("groupDestroy"));
5054 }
5055 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5056;
5057 }
5058 GeneratedField::GroupMerge => {
5059 if delta_type__.is_some() {
5060 return Err(serde::de::Error::duplicate_field("groupMerge"));
5061 }
5062 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5063;
5064 }
5065 GeneratedField::NewL0SubLevel => {
5066 if delta_type__.is_some() {
5067 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5068 }
5069 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5070;
5071 }
5072 GeneratedField::TruncateTables => {
5073 if delta_type__.is_some() {
5074 return Err(serde::de::Error::duplicate_field("truncateTables"));
5075 }
5076 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::TruncateTables)
5077;
5078 }
5079 }
5080 }
5081 Ok(GroupDelta {
5082 delta_type: delta_type__,
5083 })
5084 }
5085 }
5086 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5087 }
5088}
5089impl serde::Serialize for GroupDestroy {
5090 #[allow(deprecated)]
5091 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5092 where
5093 S: serde::Serializer,
5094 {
5095 use serde::ser::SerializeStruct;
5096 let len = 0;
5097 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5098 struct_ser.end()
5099 }
5100}
5101impl<'de> serde::Deserialize<'de> for GroupDestroy {
5102 #[allow(deprecated)]
5103 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5104 where
5105 D: serde::Deserializer<'de>,
5106 {
5107 const FIELDS: &[&str] = &[
5108 ];
5109
5110 #[allow(clippy::enum_variant_names)]
5111 enum GeneratedField {
5112 }
5113 impl<'de> serde::Deserialize<'de> for GeneratedField {
5114 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5115 where
5116 D: serde::Deserializer<'de>,
5117 {
5118 struct GeneratedVisitor;
5119
5120 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5121 type Value = GeneratedField;
5122
5123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5124 write!(formatter, "expected one of: {:?}", &FIELDS)
5125 }
5126
5127 #[allow(unused_variables)]
5128 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5129 where
5130 E: serde::de::Error,
5131 {
5132 Err(serde::de::Error::unknown_field(value, FIELDS))
5133 }
5134 }
5135 deserializer.deserialize_identifier(GeneratedVisitor)
5136 }
5137 }
5138 struct GeneratedVisitor;
5139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5140 type Value = GroupDestroy;
5141
5142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5143 formatter.write_str("struct hummock.GroupDestroy")
5144 }
5145
5146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5147 where
5148 V: serde::de::MapAccess<'de>,
5149 {
5150 while map_.next_key::<GeneratedField>()?.is_some() {
5151 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5152 }
5153 Ok(GroupDestroy {
5154 })
5155 }
5156 }
5157 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5158 }
5159}
5160impl serde::Serialize for GroupMerge {
5161 #[allow(deprecated)]
5162 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5163 where
5164 S: serde::Serializer,
5165 {
5166 use serde::ser::SerializeStruct;
5167 let mut len = 0;
5168 if self.left_group_id != 0 {
5169 len += 1;
5170 }
5171 if self.right_group_id != 0 {
5172 len += 1;
5173 }
5174 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5175 if self.left_group_id != 0 {
5176 #[allow(clippy::needless_borrow)]
5177 #[allow(clippy::needless_borrows_for_generic_args)]
5178 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5179 }
5180 if self.right_group_id != 0 {
5181 #[allow(clippy::needless_borrow)]
5182 #[allow(clippy::needless_borrows_for_generic_args)]
5183 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5184 }
5185 struct_ser.end()
5186 }
5187}
5188impl<'de> serde::Deserialize<'de> for GroupMerge {
5189 #[allow(deprecated)]
5190 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5191 where
5192 D: serde::Deserializer<'de>,
5193 {
5194 const FIELDS: &[&str] = &[
5195 "left_group_id",
5196 "leftGroupId",
5197 "right_group_id",
5198 "rightGroupId",
5199 ];
5200
5201 #[allow(clippy::enum_variant_names)]
5202 enum GeneratedField {
5203 LeftGroupId,
5204 RightGroupId,
5205 }
5206 impl<'de> serde::Deserialize<'de> for GeneratedField {
5207 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5208 where
5209 D: serde::Deserializer<'de>,
5210 {
5211 struct GeneratedVisitor;
5212
5213 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5214 type Value = GeneratedField;
5215
5216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5217 write!(formatter, "expected one of: {:?}", &FIELDS)
5218 }
5219
5220 #[allow(unused_variables)]
5221 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5222 where
5223 E: serde::de::Error,
5224 {
5225 match value {
5226 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5227 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5228 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5229 }
5230 }
5231 }
5232 deserializer.deserialize_identifier(GeneratedVisitor)
5233 }
5234 }
5235 struct GeneratedVisitor;
5236 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5237 type Value = GroupMerge;
5238
5239 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5240 formatter.write_str("struct hummock.GroupMerge")
5241 }
5242
5243 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5244 where
5245 V: serde::de::MapAccess<'de>,
5246 {
5247 let mut left_group_id__ = None;
5248 let mut right_group_id__ = None;
5249 while let Some(k) = map_.next_key()? {
5250 match k {
5251 GeneratedField::LeftGroupId => {
5252 if left_group_id__.is_some() {
5253 return Err(serde::de::Error::duplicate_field("leftGroupId"));
5254 }
5255 left_group_id__ =
5256 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5257 ;
5258 }
5259 GeneratedField::RightGroupId => {
5260 if right_group_id__.is_some() {
5261 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5262 }
5263 right_group_id__ =
5264 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5265 ;
5266 }
5267 }
5268 }
5269 Ok(GroupMerge {
5270 left_group_id: left_group_id__.unwrap_or_default(),
5271 right_group_id: right_group_id__.unwrap_or_default(),
5272 })
5273 }
5274 }
5275 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5276 }
5277}
5278impl serde::Serialize for HnswFlatIndex {
5279 #[allow(deprecated)]
5280 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5281 where
5282 S: serde::Serializer,
5283 {
5284 use serde::ser::SerializeStruct;
5285 let mut len = 0;
5286 if self.config.is_some() {
5287 len += 1;
5288 }
5289 if !self.vector_files.is_empty() {
5290 len += 1;
5291 }
5292 if self.next_vector_id != 0 {
5293 len += 1;
5294 }
5295 if self.graph_file.is_some() {
5296 len += 1;
5297 }
5298 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndex", len)?;
5299 if let Some(v) = self.config.as_ref() {
5300 struct_ser.serialize_field("config", v)?;
5301 }
5302 if !self.vector_files.is_empty() {
5303 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
5304 }
5305 if self.next_vector_id != 0 {
5306 #[allow(clippy::needless_borrow)]
5307 #[allow(clippy::needless_borrows_for_generic_args)]
5308 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5309 }
5310 if let Some(v) = self.graph_file.as_ref() {
5311 struct_ser.serialize_field("graphFile", v)?;
5312 }
5313 struct_ser.end()
5314 }
5315}
5316impl<'de> serde::Deserialize<'de> for HnswFlatIndex {
5317 #[allow(deprecated)]
5318 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5319 where
5320 D: serde::Deserializer<'de>,
5321 {
5322 const FIELDS: &[&str] = &[
5323 "config",
5324 "vector_files",
5325 "vectorFiles",
5326 "next_vector_id",
5327 "nextVectorId",
5328 "graph_file",
5329 "graphFile",
5330 ];
5331
5332 #[allow(clippy::enum_variant_names)]
5333 enum GeneratedField {
5334 Config,
5335 VectorFiles,
5336 NextVectorId,
5337 GraphFile,
5338 }
5339 impl<'de> serde::Deserialize<'de> for GeneratedField {
5340 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5341 where
5342 D: serde::Deserializer<'de>,
5343 {
5344 struct GeneratedVisitor;
5345
5346 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5347 type Value = GeneratedField;
5348
5349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5350 write!(formatter, "expected one of: {:?}", &FIELDS)
5351 }
5352
5353 #[allow(unused_variables)]
5354 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5355 where
5356 E: serde::de::Error,
5357 {
5358 match value {
5359 "config" => Ok(GeneratedField::Config),
5360 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
5361 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
5362 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
5363 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5364 }
5365 }
5366 }
5367 deserializer.deserialize_identifier(GeneratedVisitor)
5368 }
5369 }
5370 struct GeneratedVisitor;
5371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5372 type Value = HnswFlatIndex;
5373
5374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5375 formatter.write_str("struct hummock.HnswFlatIndex")
5376 }
5377
5378 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndex, V::Error>
5379 where
5380 V: serde::de::MapAccess<'de>,
5381 {
5382 let mut config__ = None;
5383 let mut vector_files__ = None;
5384 let mut next_vector_id__ = None;
5385 let mut graph_file__ = None;
5386 while let Some(k) = map_.next_key()? {
5387 match k {
5388 GeneratedField::Config => {
5389 if config__.is_some() {
5390 return Err(serde::de::Error::duplicate_field("config"));
5391 }
5392 config__ = map_.next_value()?;
5393 }
5394 GeneratedField::VectorFiles => {
5395 if vector_files__.is_some() {
5396 return Err(serde::de::Error::duplicate_field("vectorFiles"));
5397 }
5398 vector_files__ = Some(map_.next_value()?);
5399 }
5400 GeneratedField::NextVectorId => {
5401 if next_vector_id__.is_some() {
5402 return Err(serde::de::Error::duplicate_field("nextVectorId"));
5403 }
5404 next_vector_id__ =
5405 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5406 ;
5407 }
5408 GeneratedField::GraphFile => {
5409 if graph_file__.is_some() {
5410 return Err(serde::de::Error::duplicate_field("graphFile"));
5411 }
5412 graph_file__ = map_.next_value()?;
5413 }
5414 }
5415 }
5416 Ok(HnswFlatIndex {
5417 config: config__,
5418 vector_files: vector_files__.unwrap_or_default(),
5419 next_vector_id: next_vector_id__.unwrap_or_default(),
5420 graph_file: graph_file__,
5421 })
5422 }
5423 }
5424 deserializer.deserialize_struct("hummock.HnswFlatIndex", FIELDS, GeneratedVisitor)
5425 }
5426}
5427impl serde::Serialize for HnswFlatIndexAdd {
5428 #[allow(deprecated)]
5429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5430 where
5431 S: serde::Serializer,
5432 {
5433 use serde::ser::SerializeStruct;
5434 let mut len = 0;
5435 if !self.added_vector_files.is_empty() {
5436 len += 1;
5437 }
5438 if self.next_vector_id != 0 {
5439 len += 1;
5440 }
5441 if self.graph_file.is_some() {
5442 len += 1;
5443 }
5444 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndexAdd", len)?;
5445 if !self.added_vector_files.is_empty() {
5446 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
5447 }
5448 if self.next_vector_id != 0 {
5449 #[allow(clippy::needless_borrow)]
5450 #[allow(clippy::needless_borrows_for_generic_args)]
5451 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5452 }
5453 if let Some(v) = self.graph_file.as_ref() {
5454 struct_ser.serialize_field("graphFile", v)?;
5455 }
5456 struct_ser.end()
5457 }
5458}
5459impl<'de> serde::Deserialize<'de> for HnswFlatIndexAdd {
5460 #[allow(deprecated)]
5461 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5462 where
5463 D: serde::Deserializer<'de>,
5464 {
5465 const FIELDS: &[&str] = &[
5466 "added_vector_files",
5467 "addedVectorFiles",
5468 "next_vector_id",
5469 "nextVectorId",
5470 "graph_file",
5471 "graphFile",
5472 ];
5473
5474 #[allow(clippy::enum_variant_names)]
5475 enum GeneratedField {
5476 AddedVectorFiles,
5477 NextVectorId,
5478 GraphFile,
5479 }
5480 impl<'de> serde::Deserialize<'de> for GeneratedField {
5481 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5482 where
5483 D: serde::Deserializer<'de>,
5484 {
5485 struct GeneratedVisitor;
5486
5487 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5488 type Value = GeneratedField;
5489
5490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5491 write!(formatter, "expected one of: {:?}", &FIELDS)
5492 }
5493
5494 #[allow(unused_variables)]
5495 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5496 where
5497 E: serde::de::Error,
5498 {
5499 match value {
5500 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
5501 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
5502 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
5503 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5504 }
5505 }
5506 }
5507 deserializer.deserialize_identifier(GeneratedVisitor)
5508 }
5509 }
5510 struct GeneratedVisitor;
5511 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5512 type Value = HnswFlatIndexAdd;
5513
5514 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5515 formatter.write_str("struct hummock.HnswFlatIndexAdd")
5516 }
5517
5518 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndexAdd, V::Error>
5519 where
5520 V: serde::de::MapAccess<'de>,
5521 {
5522 let mut added_vector_files__ = None;
5523 let mut next_vector_id__ = None;
5524 let mut graph_file__ = None;
5525 while let Some(k) = map_.next_key()? {
5526 match k {
5527 GeneratedField::AddedVectorFiles => {
5528 if added_vector_files__.is_some() {
5529 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
5530 }
5531 added_vector_files__ = Some(map_.next_value()?);
5532 }
5533 GeneratedField::NextVectorId => {
5534 if next_vector_id__.is_some() {
5535 return Err(serde::de::Error::duplicate_field("nextVectorId"));
5536 }
5537 next_vector_id__ =
5538 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5539 ;
5540 }
5541 GeneratedField::GraphFile => {
5542 if graph_file__.is_some() {
5543 return Err(serde::de::Error::duplicate_field("graphFile"));
5544 }
5545 graph_file__ = map_.next_value()?;
5546 }
5547 }
5548 }
5549 Ok(HnswFlatIndexAdd {
5550 added_vector_files: added_vector_files__.unwrap_or_default(),
5551 next_vector_id: next_vector_id__.unwrap_or_default(),
5552 graph_file: graph_file__,
5553 })
5554 }
5555 }
5556 deserializer.deserialize_struct("hummock.HnswFlatIndexAdd", FIELDS, GeneratedVisitor)
5557 }
5558}
5559impl serde::Serialize for HnswGraph {
5560 #[allow(deprecated)]
5561 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5562 where
5563 S: serde::Serializer,
5564 {
5565 use serde::ser::SerializeStruct;
5566 let mut len = 0;
5567 if !self.nodes.is_empty() {
5568 len += 1;
5569 }
5570 if self.entrypoint_id != 0 {
5571 len += 1;
5572 }
5573 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph", len)?;
5574 if !self.nodes.is_empty() {
5575 struct_ser.serialize_field("nodes", &self.nodes)?;
5576 }
5577 if self.entrypoint_id != 0 {
5578 #[allow(clippy::needless_borrow)]
5579 #[allow(clippy::needless_borrows_for_generic_args)]
5580 struct_ser.serialize_field("entrypointId", ToString::to_string(&self.entrypoint_id).as_str())?;
5581 }
5582 struct_ser.end()
5583 }
5584}
5585impl<'de> serde::Deserialize<'de> for HnswGraph {
5586 #[allow(deprecated)]
5587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5588 where
5589 D: serde::Deserializer<'de>,
5590 {
5591 const FIELDS: &[&str] = &[
5592 "nodes",
5593 "entrypoint_id",
5594 "entrypointId",
5595 ];
5596
5597 #[allow(clippy::enum_variant_names)]
5598 enum GeneratedField {
5599 Nodes,
5600 EntrypointId,
5601 }
5602 impl<'de> serde::Deserialize<'de> for GeneratedField {
5603 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5604 where
5605 D: serde::Deserializer<'de>,
5606 {
5607 struct GeneratedVisitor;
5608
5609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5610 type Value = GeneratedField;
5611
5612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5613 write!(formatter, "expected one of: {:?}", &FIELDS)
5614 }
5615
5616 #[allow(unused_variables)]
5617 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5618 where
5619 E: serde::de::Error,
5620 {
5621 match value {
5622 "nodes" => Ok(GeneratedField::Nodes),
5623 "entrypointId" | "entrypoint_id" => Ok(GeneratedField::EntrypointId),
5624 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5625 }
5626 }
5627 }
5628 deserializer.deserialize_identifier(GeneratedVisitor)
5629 }
5630 }
5631 struct GeneratedVisitor;
5632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5633 type Value = HnswGraph;
5634
5635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5636 formatter.write_str("struct hummock.HnswGraph")
5637 }
5638
5639 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraph, V::Error>
5640 where
5641 V: serde::de::MapAccess<'de>,
5642 {
5643 let mut nodes__ = None;
5644 let mut entrypoint_id__ = None;
5645 while let Some(k) = map_.next_key()? {
5646 match k {
5647 GeneratedField::Nodes => {
5648 if nodes__.is_some() {
5649 return Err(serde::de::Error::duplicate_field("nodes"));
5650 }
5651 nodes__ = Some(map_.next_value()?);
5652 }
5653 GeneratedField::EntrypointId => {
5654 if entrypoint_id__.is_some() {
5655 return Err(serde::de::Error::duplicate_field("entrypointId"));
5656 }
5657 entrypoint_id__ =
5658 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5659 ;
5660 }
5661 }
5662 }
5663 Ok(HnswGraph {
5664 nodes: nodes__.unwrap_or_default(),
5665 entrypoint_id: entrypoint_id__.unwrap_or_default(),
5666 })
5667 }
5668 }
5669 deserializer.deserialize_struct("hummock.HnswGraph", FIELDS, GeneratedVisitor)
5670 }
5671}
5672impl serde::Serialize for hnsw_graph::HnswLevel {
5673 #[allow(deprecated)]
5674 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5675 where
5676 S: serde::Serializer,
5677 {
5678 use serde::ser::SerializeStruct;
5679 let mut len = 0;
5680 if !self.neighbors.is_empty() {
5681 len += 1;
5682 }
5683 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswLevel", len)?;
5684 if !self.neighbors.is_empty() {
5685 struct_ser.serialize_field("neighbors", &self.neighbors)?;
5686 }
5687 struct_ser.end()
5688 }
5689}
5690impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswLevel {
5691 #[allow(deprecated)]
5692 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5693 where
5694 D: serde::Deserializer<'de>,
5695 {
5696 const FIELDS: &[&str] = &[
5697 "neighbors",
5698 ];
5699
5700 #[allow(clippy::enum_variant_names)]
5701 enum GeneratedField {
5702 Neighbors,
5703 }
5704 impl<'de> serde::Deserialize<'de> for GeneratedField {
5705 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5706 where
5707 D: serde::Deserializer<'de>,
5708 {
5709 struct GeneratedVisitor;
5710
5711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5712 type Value = GeneratedField;
5713
5714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5715 write!(formatter, "expected one of: {:?}", &FIELDS)
5716 }
5717
5718 #[allow(unused_variables)]
5719 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5720 where
5721 E: serde::de::Error,
5722 {
5723 match value {
5724 "neighbors" => Ok(GeneratedField::Neighbors),
5725 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5726 }
5727 }
5728 }
5729 deserializer.deserialize_identifier(GeneratedVisitor)
5730 }
5731 }
5732 struct GeneratedVisitor;
5733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5734 type Value = hnsw_graph::HnswLevel;
5735
5736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5737 formatter.write_str("struct hummock.HnswGraph.HnswLevel")
5738 }
5739
5740 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswLevel, V::Error>
5741 where
5742 V: serde::de::MapAccess<'de>,
5743 {
5744 let mut neighbors__ = None;
5745 while let Some(k) = map_.next_key()? {
5746 match k {
5747 GeneratedField::Neighbors => {
5748 if neighbors__.is_some() {
5749 return Err(serde::de::Error::duplicate_field("neighbors"));
5750 }
5751 neighbors__ = Some(map_.next_value()?);
5752 }
5753 }
5754 }
5755 Ok(hnsw_graph::HnswLevel {
5756 neighbors: neighbors__.unwrap_or_default(),
5757 })
5758 }
5759 }
5760 deserializer.deserialize_struct("hummock.HnswGraph.HnswLevel", FIELDS, GeneratedVisitor)
5761 }
5762}
5763impl serde::Serialize for hnsw_graph::HnswNeighbor {
5764 #[allow(deprecated)]
5765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5766 where
5767 S: serde::Serializer,
5768 {
5769 use serde::ser::SerializeStruct;
5770 let mut len = 0;
5771 if self.vector_id != 0 {
5772 len += 1;
5773 }
5774 if self.distance != 0. {
5775 len += 1;
5776 }
5777 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNeighbor", len)?;
5778 if self.vector_id != 0 {
5779 #[allow(clippy::needless_borrow)]
5780 #[allow(clippy::needless_borrows_for_generic_args)]
5781 struct_ser.serialize_field("vectorId", ToString::to_string(&self.vector_id).as_str())?;
5782 }
5783 if self.distance != 0. {
5784 struct_ser.serialize_field("distance", &self.distance)?;
5785 }
5786 struct_ser.end()
5787 }
5788}
5789impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNeighbor {
5790 #[allow(deprecated)]
5791 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5792 where
5793 D: serde::Deserializer<'de>,
5794 {
5795 const FIELDS: &[&str] = &[
5796 "vector_id",
5797 "vectorId",
5798 "distance",
5799 ];
5800
5801 #[allow(clippy::enum_variant_names)]
5802 enum GeneratedField {
5803 VectorId,
5804 Distance,
5805 }
5806 impl<'de> serde::Deserialize<'de> for GeneratedField {
5807 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5808 where
5809 D: serde::Deserializer<'de>,
5810 {
5811 struct GeneratedVisitor;
5812
5813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5814 type Value = GeneratedField;
5815
5816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5817 write!(formatter, "expected one of: {:?}", &FIELDS)
5818 }
5819
5820 #[allow(unused_variables)]
5821 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5822 where
5823 E: serde::de::Error,
5824 {
5825 match value {
5826 "vectorId" | "vector_id" => Ok(GeneratedField::VectorId),
5827 "distance" => Ok(GeneratedField::Distance),
5828 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5829 }
5830 }
5831 }
5832 deserializer.deserialize_identifier(GeneratedVisitor)
5833 }
5834 }
5835 struct GeneratedVisitor;
5836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5837 type Value = hnsw_graph::HnswNeighbor;
5838
5839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5840 formatter.write_str("struct hummock.HnswGraph.HnswNeighbor")
5841 }
5842
5843 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNeighbor, V::Error>
5844 where
5845 V: serde::de::MapAccess<'de>,
5846 {
5847 let mut vector_id__ = None;
5848 let mut distance__ = None;
5849 while let Some(k) = map_.next_key()? {
5850 match k {
5851 GeneratedField::VectorId => {
5852 if vector_id__.is_some() {
5853 return Err(serde::de::Error::duplicate_field("vectorId"));
5854 }
5855 vector_id__ =
5856 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5857 ;
5858 }
5859 GeneratedField::Distance => {
5860 if distance__.is_some() {
5861 return Err(serde::de::Error::duplicate_field("distance"));
5862 }
5863 distance__ =
5864 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5865 ;
5866 }
5867 }
5868 }
5869 Ok(hnsw_graph::HnswNeighbor {
5870 vector_id: vector_id__.unwrap_or_default(),
5871 distance: distance__.unwrap_or_default(),
5872 })
5873 }
5874 }
5875 deserializer.deserialize_struct("hummock.HnswGraph.HnswNeighbor", FIELDS, GeneratedVisitor)
5876 }
5877}
5878impl serde::Serialize for hnsw_graph::HnswNode {
5879 #[allow(deprecated)]
5880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5881 where
5882 S: serde::Serializer,
5883 {
5884 use serde::ser::SerializeStruct;
5885 let mut len = 0;
5886 if !self.levels.is_empty() {
5887 len += 1;
5888 }
5889 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNode", len)?;
5890 if !self.levels.is_empty() {
5891 struct_ser.serialize_field("levels", &self.levels)?;
5892 }
5893 struct_ser.end()
5894 }
5895}
5896impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNode {
5897 #[allow(deprecated)]
5898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5899 where
5900 D: serde::Deserializer<'de>,
5901 {
5902 const FIELDS: &[&str] = &[
5903 "levels",
5904 ];
5905
5906 #[allow(clippy::enum_variant_names)]
5907 enum GeneratedField {
5908 Levels,
5909 }
5910 impl<'de> serde::Deserialize<'de> for GeneratedField {
5911 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5912 where
5913 D: serde::Deserializer<'de>,
5914 {
5915 struct GeneratedVisitor;
5916
5917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5918 type Value = GeneratedField;
5919
5920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5921 write!(formatter, "expected one of: {:?}", &FIELDS)
5922 }
5923
5924 #[allow(unused_variables)]
5925 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5926 where
5927 E: serde::de::Error,
5928 {
5929 match value {
5930 "levels" => Ok(GeneratedField::Levels),
5931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5932 }
5933 }
5934 }
5935 deserializer.deserialize_identifier(GeneratedVisitor)
5936 }
5937 }
5938 struct GeneratedVisitor;
5939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5940 type Value = hnsw_graph::HnswNode;
5941
5942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5943 formatter.write_str("struct hummock.HnswGraph.HnswNode")
5944 }
5945
5946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNode, V::Error>
5947 where
5948 V: serde::de::MapAccess<'de>,
5949 {
5950 let mut levels__ = None;
5951 while let Some(k) = map_.next_key()? {
5952 match k {
5953 GeneratedField::Levels => {
5954 if levels__.is_some() {
5955 return Err(serde::de::Error::duplicate_field("levels"));
5956 }
5957 levels__ = Some(map_.next_value()?);
5958 }
5959 }
5960 }
5961 Ok(hnsw_graph::HnswNode {
5962 levels: levels__.unwrap_or_default(),
5963 })
5964 }
5965 }
5966 deserializer.deserialize_struct("hummock.HnswGraph.HnswNode", FIELDS, GeneratedVisitor)
5967 }
5968}
5969impl serde::Serialize for HnswGraphFileInfo {
5970 #[allow(deprecated)]
5971 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5972 where
5973 S: serde::Serializer,
5974 {
5975 use serde::ser::SerializeStruct;
5976 let mut len = 0;
5977 if self.object_id != 0 {
5978 len += 1;
5979 }
5980 if self.file_size != 0 {
5981 len += 1;
5982 }
5983 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraphFileInfo", len)?;
5984 if self.object_id != 0 {
5985 #[allow(clippy::needless_borrow)]
5986 #[allow(clippy::needless_borrows_for_generic_args)]
5987 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
5988 }
5989 if self.file_size != 0 {
5990 #[allow(clippy::needless_borrow)]
5991 #[allow(clippy::needless_borrows_for_generic_args)]
5992 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
5993 }
5994 struct_ser.end()
5995 }
5996}
5997impl<'de> serde::Deserialize<'de> for HnswGraphFileInfo {
5998 #[allow(deprecated)]
5999 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6000 where
6001 D: serde::Deserializer<'de>,
6002 {
6003 const FIELDS: &[&str] = &[
6004 "object_id",
6005 "objectId",
6006 "file_size",
6007 "fileSize",
6008 ];
6009
6010 #[allow(clippy::enum_variant_names)]
6011 enum GeneratedField {
6012 ObjectId,
6013 FileSize,
6014 }
6015 impl<'de> serde::Deserialize<'de> for GeneratedField {
6016 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6017 where
6018 D: serde::Deserializer<'de>,
6019 {
6020 struct GeneratedVisitor;
6021
6022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6023 type Value = GeneratedField;
6024
6025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6026 write!(formatter, "expected one of: {:?}", &FIELDS)
6027 }
6028
6029 #[allow(unused_variables)]
6030 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6031 where
6032 E: serde::de::Error,
6033 {
6034 match value {
6035 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
6036 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
6037 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6038 }
6039 }
6040 }
6041 deserializer.deserialize_identifier(GeneratedVisitor)
6042 }
6043 }
6044 struct GeneratedVisitor;
6045 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6046 type Value = HnswGraphFileInfo;
6047
6048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6049 formatter.write_str("struct hummock.HnswGraphFileInfo")
6050 }
6051
6052 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraphFileInfo, V::Error>
6053 where
6054 V: serde::de::MapAccess<'de>,
6055 {
6056 let mut object_id__ = None;
6057 let mut file_size__ = None;
6058 while let Some(k) = map_.next_key()? {
6059 match k {
6060 GeneratedField::ObjectId => {
6061 if object_id__.is_some() {
6062 return Err(serde::de::Error::duplicate_field("objectId"));
6063 }
6064 object_id__ =
6065 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6066 ;
6067 }
6068 GeneratedField::FileSize => {
6069 if file_size__.is_some() {
6070 return Err(serde::de::Error::duplicate_field("fileSize"));
6071 }
6072 file_size__ =
6073 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6074 ;
6075 }
6076 }
6077 }
6078 Ok(HnswGraphFileInfo {
6079 object_id: object_id__.unwrap_or_default(),
6080 file_size: file_size__.unwrap_or_default(),
6081 })
6082 }
6083 }
6084 deserializer.deserialize_struct("hummock.HnswGraphFileInfo", FIELDS, GeneratedVisitor)
6085 }
6086}
6087impl serde::Serialize for HummockPinnedSnapshot {
6088 #[allow(deprecated)]
6089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6090 where
6091 S: serde::Serializer,
6092 {
6093 use serde::ser::SerializeStruct;
6094 let mut len = 0;
6095 if self.context_id != 0 {
6096 len += 1;
6097 }
6098 if self.minimal_pinned_snapshot != 0 {
6099 len += 1;
6100 }
6101 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
6102 if self.context_id != 0 {
6103 struct_ser.serialize_field("contextId", &self.context_id)?;
6104 }
6105 if self.minimal_pinned_snapshot != 0 {
6106 #[allow(clippy::needless_borrow)]
6107 #[allow(clippy::needless_borrows_for_generic_args)]
6108 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
6109 }
6110 struct_ser.end()
6111 }
6112}
6113impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
6114 #[allow(deprecated)]
6115 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6116 where
6117 D: serde::Deserializer<'de>,
6118 {
6119 const FIELDS: &[&str] = &[
6120 "context_id",
6121 "contextId",
6122 "minimal_pinned_snapshot",
6123 "minimalPinnedSnapshot",
6124 ];
6125
6126 #[allow(clippy::enum_variant_names)]
6127 enum GeneratedField {
6128 ContextId,
6129 MinimalPinnedSnapshot,
6130 }
6131 impl<'de> serde::Deserialize<'de> for GeneratedField {
6132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6133 where
6134 D: serde::Deserializer<'de>,
6135 {
6136 struct GeneratedVisitor;
6137
6138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6139 type Value = GeneratedField;
6140
6141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6142 write!(formatter, "expected one of: {:?}", &FIELDS)
6143 }
6144
6145 #[allow(unused_variables)]
6146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6147 where
6148 E: serde::de::Error,
6149 {
6150 match value {
6151 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6152 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
6153 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6154 }
6155 }
6156 }
6157 deserializer.deserialize_identifier(GeneratedVisitor)
6158 }
6159 }
6160 struct GeneratedVisitor;
6161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6162 type Value = HummockPinnedSnapshot;
6163
6164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6165 formatter.write_str("struct hummock.HummockPinnedSnapshot")
6166 }
6167
6168 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
6169 where
6170 V: serde::de::MapAccess<'de>,
6171 {
6172 let mut context_id__ = None;
6173 let mut minimal_pinned_snapshot__ = None;
6174 while let Some(k) = map_.next_key()? {
6175 match k {
6176 GeneratedField::ContextId => {
6177 if context_id__.is_some() {
6178 return Err(serde::de::Error::duplicate_field("contextId"));
6179 }
6180 context_id__ =
6181 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6182 ;
6183 }
6184 GeneratedField::MinimalPinnedSnapshot => {
6185 if minimal_pinned_snapshot__.is_some() {
6186 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
6187 }
6188 minimal_pinned_snapshot__ =
6189 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6190 ;
6191 }
6192 }
6193 }
6194 Ok(HummockPinnedSnapshot {
6195 context_id: context_id__.unwrap_or_default(),
6196 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
6197 })
6198 }
6199 }
6200 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
6201 }
6202}
6203impl serde::Serialize for HummockPinnedVersion {
6204 #[allow(deprecated)]
6205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6206 where
6207 S: serde::Serializer,
6208 {
6209 use serde::ser::SerializeStruct;
6210 let mut len = 0;
6211 if self.context_id != 0 {
6212 len += 1;
6213 }
6214 if self.min_pinned_id != 0 {
6215 len += 1;
6216 }
6217 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
6218 if self.context_id != 0 {
6219 struct_ser.serialize_field("contextId", &self.context_id)?;
6220 }
6221 if self.min_pinned_id != 0 {
6222 #[allow(clippy::needless_borrow)]
6223 #[allow(clippy::needless_borrows_for_generic_args)]
6224 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
6225 }
6226 struct_ser.end()
6227 }
6228}
6229impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
6230 #[allow(deprecated)]
6231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6232 where
6233 D: serde::Deserializer<'de>,
6234 {
6235 const FIELDS: &[&str] = &[
6236 "context_id",
6237 "contextId",
6238 "min_pinned_id",
6239 "minPinnedId",
6240 ];
6241
6242 #[allow(clippy::enum_variant_names)]
6243 enum GeneratedField {
6244 ContextId,
6245 MinPinnedId,
6246 }
6247 impl<'de> serde::Deserialize<'de> for GeneratedField {
6248 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6249 where
6250 D: serde::Deserializer<'de>,
6251 {
6252 struct GeneratedVisitor;
6253
6254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6255 type Value = GeneratedField;
6256
6257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6258 write!(formatter, "expected one of: {:?}", &FIELDS)
6259 }
6260
6261 #[allow(unused_variables)]
6262 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6263 where
6264 E: serde::de::Error,
6265 {
6266 match value {
6267 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6268 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
6269 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6270 }
6271 }
6272 }
6273 deserializer.deserialize_identifier(GeneratedVisitor)
6274 }
6275 }
6276 struct GeneratedVisitor;
6277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6278 type Value = HummockPinnedVersion;
6279
6280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6281 formatter.write_str("struct hummock.HummockPinnedVersion")
6282 }
6283
6284 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
6285 where
6286 V: serde::de::MapAccess<'de>,
6287 {
6288 let mut context_id__ = None;
6289 let mut min_pinned_id__ = None;
6290 while let Some(k) = map_.next_key()? {
6291 match k {
6292 GeneratedField::ContextId => {
6293 if context_id__.is_some() {
6294 return Err(serde::de::Error::duplicate_field("contextId"));
6295 }
6296 context_id__ =
6297 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6298 ;
6299 }
6300 GeneratedField::MinPinnedId => {
6301 if min_pinned_id__.is_some() {
6302 return Err(serde::de::Error::duplicate_field("minPinnedId"));
6303 }
6304 min_pinned_id__ =
6305 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6306 ;
6307 }
6308 }
6309 }
6310 Ok(HummockPinnedVersion {
6311 context_id: context_id__.unwrap_or_default(),
6312 min_pinned_id: min_pinned_id__.unwrap_or_default(),
6313 })
6314 }
6315 }
6316 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
6317 }
6318}
6319impl serde::Serialize for HummockVersion {
6320 #[allow(deprecated)]
6321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6322 where
6323 S: serde::Serializer,
6324 {
6325 use serde::ser::SerializeStruct;
6326 let mut len = 0;
6327 if self.id != 0 {
6328 len += 1;
6329 }
6330 if !self.levels.is_empty() {
6331 len += 1;
6332 }
6333 if self.max_committed_epoch != 0 {
6334 len += 1;
6335 }
6336 if !self.table_watermarks.is_empty() {
6337 len += 1;
6338 }
6339 if !self.table_change_logs.is_empty() {
6340 len += 1;
6341 }
6342 if !self.state_table_info.is_empty() {
6343 len += 1;
6344 }
6345 if !self.vector_indexes.is_empty() {
6346 len += 1;
6347 }
6348 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
6349 if self.id != 0 {
6350 #[allow(clippy::needless_borrow)]
6351 #[allow(clippy::needless_borrows_for_generic_args)]
6352 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6353 }
6354 if !self.levels.is_empty() {
6355 struct_ser.serialize_field("levels", &self.levels)?;
6356 }
6357 if self.max_committed_epoch != 0 {
6358 #[allow(clippy::needless_borrow)]
6359 #[allow(clippy::needless_borrows_for_generic_args)]
6360 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6361 }
6362 if !self.table_watermarks.is_empty() {
6363 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
6364 }
6365 if !self.table_change_logs.is_empty() {
6366 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
6367 }
6368 if !self.state_table_info.is_empty() {
6369 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
6370 }
6371 if !self.vector_indexes.is_empty() {
6372 struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
6373 }
6374 struct_ser.end()
6375 }
6376}
6377impl<'de> serde::Deserialize<'de> for HummockVersion {
6378 #[allow(deprecated)]
6379 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6380 where
6381 D: serde::Deserializer<'de>,
6382 {
6383 const FIELDS: &[&str] = &[
6384 "id",
6385 "levels",
6386 "max_committed_epoch",
6387 "maxCommittedEpoch",
6388 "table_watermarks",
6389 "tableWatermarks",
6390 "table_change_logs",
6391 "tableChangeLogs",
6392 "state_table_info",
6393 "stateTableInfo",
6394 "vector_indexes",
6395 "vectorIndexes",
6396 ];
6397
6398 #[allow(clippy::enum_variant_names)]
6399 enum GeneratedField {
6400 Id,
6401 Levels,
6402 MaxCommittedEpoch,
6403 TableWatermarks,
6404 TableChangeLogs,
6405 StateTableInfo,
6406 VectorIndexes,
6407 }
6408 impl<'de> serde::Deserialize<'de> for GeneratedField {
6409 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6410 where
6411 D: serde::Deserializer<'de>,
6412 {
6413 struct GeneratedVisitor;
6414
6415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6416 type Value = GeneratedField;
6417
6418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6419 write!(formatter, "expected one of: {:?}", &FIELDS)
6420 }
6421
6422 #[allow(unused_variables)]
6423 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6424 where
6425 E: serde::de::Error,
6426 {
6427 match value {
6428 "id" => Ok(GeneratedField::Id),
6429 "levels" => Ok(GeneratedField::Levels),
6430 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6431 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
6432 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
6433 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
6434 "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
6435 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6436 }
6437 }
6438 }
6439 deserializer.deserialize_identifier(GeneratedVisitor)
6440 }
6441 }
6442 struct GeneratedVisitor;
6443 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6444 type Value = HummockVersion;
6445
6446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6447 formatter.write_str("struct hummock.HummockVersion")
6448 }
6449
6450 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
6451 where
6452 V: serde::de::MapAccess<'de>,
6453 {
6454 let mut id__ = None;
6455 let mut levels__ = None;
6456 let mut max_committed_epoch__ = None;
6457 let mut table_watermarks__ = None;
6458 let mut table_change_logs__ = None;
6459 let mut state_table_info__ = None;
6460 let mut vector_indexes__ = None;
6461 while let Some(k) = map_.next_key()? {
6462 match k {
6463 GeneratedField::Id => {
6464 if id__.is_some() {
6465 return Err(serde::de::Error::duplicate_field("id"));
6466 }
6467 id__ =
6468 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6469 ;
6470 }
6471 GeneratedField::Levels => {
6472 if levels__.is_some() {
6473 return Err(serde::de::Error::duplicate_field("levels"));
6474 }
6475 levels__ = Some(
6476 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6477 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6478 );
6479 }
6480 GeneratedField::MaxCommittedEpoch => {
6481 if max_committed_epoch__.is_some() {
6482 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
6483 }
6484 max_committed_epoch__ =
6485 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6486 ;
6487 }
6488 GeneratedField::TableWatermarks => {
6489 if table_watermarks__.is_some() {
6490 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
6491 }
6492 table_watermarks__ = Some(
6493 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6494 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6495 );
6496 }
6497 GeneratedField::TableChangeLogs => {
6498 if table_change_logs__.is_some() {
6499 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
6500 }
6501 table_change_logs__ = Some(
6502 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6503 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6504 );
6505 }
6506 GeneratedField::StateTableInfo => {
6507 if state_table_info__.is_some() {
6508 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
6509 }
6510 state_table_info__ = Some(
6511 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6512 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6513 );
6514 }
6515 GeneratedField::VectorIndexes => {
6516 if vector_indexes__.is_some() {
6517 return Err(serde::de::Error::duplicate_field("vectorIndexes"));
6518 }
6519 vector_indexes__ = Some(
6520 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6521 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6522 );
6523 }
6524 }
6525 }
6526 Ok(HummockVersion {
6527 id: id__.unwrap_or_default(),
6528 levels: levels__.unwrap_or_default(),
6529 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
6530 table_watermarks: table_watermarks__.unwrap_or_default(),
6531 table_change_logs: table_change_logs__.unwrap_or_default(),
6532 state_table_info: state_table_info__.unwrap_or_default(),
6533 vector_indexes: vector_indexes__.unwrap_or_default(),
6534 })
6535 }
6536 }
6537 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
6538 }
6539}
6540impl serde::Serialize for hummock_version::Levels {
6541 #[allow(deprecated)]
6542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6543 where
6544 S: serde::Serializer,
6545 {
6546 use serde::ser::SerializeStruct;
6547 let mut len = 0;
6548 if !self.levels.is_empty() {
6549 len += 1;
6550 }
6551 if self.l0.is_some() {
6552 len += 1;
6553 }
6554 if self.group_id != 0 {
6555 len += 1;
6556 }
6557 if self.parent_group_id != 0 {
6558 len += 1;
6559 }
6560 if !self.member_table_ids.is_empty() {
6561 len += 1;
6562 }
6563 if self.compaction_group_version_id != 0 {
6564 len += 1;
6565 }
6566 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
6567 if !self.levels.is_empty() {
6568 struct_ser.serialize_field("levels", &self.levels)?;
6569 }
6570 if let Some(v) = self.l0.as_ref() {
6571 struct_ser.serialize_field("l0", v)?;
6572 }
6573 if self.group_id != 0 {
6574 #[allow(clippy::needless_borrow)]
6575 #[allow(clippy::needless_borrows_for_generic_args)]
6576 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
6577 }
6578 if self.parent_group_id != 0 {
6579 #[allow(clippy::needless_borrow)]
6580 #[allow(clippy::needless_borrows_for_generic_args)]
6581 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
6582 }
6583 if !self.member_table_ids.is_empty() {
6584 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
6585 }
6586 if self.compaction_group_version_id != 0 {
6587 #[allow(clippy::needless_borrow)]
6588 #[allow(clippy::needless_borrows_for_generic_args)]
6589 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
6590 }
6591 struct_ser.end()
6592 }
6593}
6594impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
6595 #[allow(deprecated)]
6596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6597 where
6598 D: serde::Deserializer<'de>,
6599 {
6600 const FIELDS: &[&str] = &[
6601 "levels",
6602 "l0",
6603 "group_id",
6604 "groupId",
6605 "parent_group_id",
6606 "parentGroupId",
6607 "member_table_ids",
6608 "memberTableIds",
6609 "compaction_group_version_id",
6610 "compactionGroupVersionId",
6611 ];
6612
6613 #[allow(clippy::enum_variant_names)]
6614 enum GeneratedField {
6615 Levels,
6616 L0,
6617 GroupId,
6618 ParentGroupId,
6619 MemberTableIds,
6620 CompactionGroupVersionId,
6621 }
6622 impl<'de> serde::Deserialize<'de> for GeneratedField {
6623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6624 where
6625 D: serde::Deserializer<'de>,
6626 {
6627 struct GeneratedVisitor;
6628
6629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6630 type Value = GeneratedField;
6631
6632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6633 write!(formatter, "expected one of: {:?}", &FIELDS)
6634 }
6635
6636 #[allow(unused_variables)]
6637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6638 where
6639 E: serde::de::Error,
6640 {
6641 match value {
6642 "levels" => Ok(GeneratedField::Levels),
6643 "l0" => Ok(GeneratedField::L0),
6644 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
6645 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
6646 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
6647 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
6648 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6649 }
6650 }
6651 }
6652 deserializer.deserialize_identifier(GeneratedVisitor)
6653 }
6654 }
6655 struct GeneratedVisitor;
6656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6657 type Value = hummock_version::Levels;
6658
6659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6660 formatter.write_str("struct hummock.HummockVersion.Levels")
6661 }
6662
6663 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
6664 where
6665 V: serde::de::MapAccess<'de>,
6666 {
6667 let mut levels__ = None;
6668 let mut l0__ = None;
6669 let mut group_id__ = None;
6670 let mut parent_group_id__ = None;
6671 let mut member_table_ids__ = None;
6672 let mut compaction_group_version_id__ = None;
6673 while let Some(k) = map_.next_key()? {
6674 match k {
6675 GeneratedField::Levels => {
6676 if levels__.is_some() {
6677 return Err(serde::de::Error::duplicate_field("levels"));
6678 }
6679 levels__ = Some(map_.next_value()?);
6680 }
6681 GeneratedField::L0 => {
6682 if l0__.is_some() {
6683 return Err(serde::de::Error::duplicate_field("l0"));
6684 }
6685 l0__ = map_.next_value()?;
6686 }
6687 GeneratedField::GroupId => {
6688 if group_id__.is_some() {
6689 return Err(serde::de::Error::duplicate_field("groupId"));
6690 }
6691 group_id__ =
6692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6693 ;
6694 }
6695 GeneratedField::ParentGroupId => {
6696 if parent_group_id__.is_some() {
6697 return Err(serde::de::Error::duplicate_field("parentGroupId"));
6698 }
6699 parent_group_id__ =
6700 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6701 ;
6702 }
6703 GeneratedField::MemberTableIds => {
6704 if member_table_ids__.is_some() {
6705 return Err(serde::de::Error::duplicate_field("memberTableIds"));
6706 }
6707 member_table_ids__ =
6708 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6709 .into_iter().map(|x| x.0).collect())
6710 ;
6711 }
6712 GeneratedField::CompactionGroupVersionId => {
6713 if compaction_group_version_id__.is_some() {
6714 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
6715 }
6716 compaction_group_version_id__ =
6717 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6718 ;
6719 }
6720 }
6721 }
6722 Ok(hummock_version::Levels {
6723 levels: levels__.unwrap_or_default(),
6724 l0: l0__,
6725 group_id: group_id__.unwrap_or_default(),
6726 parent_group_id: parent_group_id__.unwrap_or_default(),
6727 member_table_ids: member_table_ids__.unwrap_or_default(),
6728 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
6729 })
6730 }
6731 }
6732 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
6733 }
6734}
6735impl serde::Serialize for HummockVersionArchive {
6736 #[allow(deprecated)]
6737 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6738 where
6739 S: serde::Serializer,
6740 {
6741 use serde::ser::SerializeStruct;
6742 let mut len = 0;
6743 if self.version.is_some() {
6744 len += 1;
6745 }
6746 if !self.version_deltas.is_empty() {
6747 len += 1;
6748 }
6749 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
6750 if let Some(v) = self.version.as_ref() {
6751 struct_ser.serialize_field("version", v)?;
6752 }
6753 if !self.version_deltas.is_empty() {
6754 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6755 }
6756 struct_ser.end()
6757 }
6758}
6759impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
6760 #[allow(deprecated)]
6761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6762 where
6763 D: serde::Deserializer<'de>,
6764 {
6765 const FIELDS: &[&str] = &[
6766 "version",
6767 "version_deltas",
6768 "versionDeltas",
6769 ];
6770
6771 #[allow(clippy::enum_variant_names)]
6772 enum GeneratedField {
6773 Version,
6774 VersionDeltas,
6775 }
6776 impl<'de> serde::Deserialize<'de> for GeneratedField {
6777 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6778 where
6779 D: serde::Deserializer<'de>,
6780 {
6781 struct GeneratedVisitor;
6782
6783 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6784 type Value = GeneratedField;
6785
6786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6787 write!(formatter, "expected one of: {:?}", &FIELDS)
6788 }
6789
6790 #[allow(unused_variables)]
6791 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6792 where
6793 E: serde::de::Error,
6794 {
6795 match value {
6796 "version" => Ok(GeneratedField::Version),
6797 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6798 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6799 }
6800 }
6801 }
6802 deserializer.deserialize_identifier(GeneratedVisitor)
6803 }
6804 }
6805 struct GeneratedVisitor;
6806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6807 type Value = HummockVersionArchive;
6808
6809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6810 formatter.write_str("struct hummock.HummockVersionArchive")
6811 }
6812
6813 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
6814 where
6815 V: serde::de::MapAccess<'de>,
6816 {
6817 let mut version__ = None;
6818 let mut version_deltas__ = None;
6819 while let Some(k) = map_.next_key()? {
6820 match k {
6821 GeneratedField::Version => {
6822 if version__.is_some() {
6823 return Err(serde::de::Error::duplicate_field("version"));
6824 }
6825 version__ = map_.next_value()?;
6826 }
6827 GeneratedField::VersionDeltas => {
6828 if version_deltas__.is_some() {
6829 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6830 }
6831 version_deltas__ = Some(map_.next_value()?);
6832 }
6833 }
6834 }
6835 Ok(HummockVersionArchive {
6836 version: version__,
6837 version_deltas: version_deltas__.unwrap_or_default(),
6838 })
6839 }
6840 }
6841 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
6842 }
6843}
6844impl serde::Serialize for HummockVersionCheckpoint {
6845 #[allow(deprecated)]
6846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6847 where
6848 S: serde::Serializer,
6849 {
6850 use serde::ser::SerializeStruct;
6851 let mut len = 0;
6852 if self.version.is_some() {
6853 len += 1;
6854 }
6855 if !self.stale_objects.is_empty() {
6856 len += 1;
6857 }
6858 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
6859 if let Some(v) = self.version.as_ref() {
6860 struct_ser.serialize_field("version", v)?;
6861 }
6862 if !self.stale_objects.is_empty() {
6863 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
6864 }
6865 struct_ser.end()
6866 }
6867}
6868impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
6869 #[allow(deprecated)]
6870 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6871 where
6872 D: serde::Deserializer<'de>,
6873 {
6874 const FIELDS: &[&str] = &[
6875 "version",
6876 "stale_objects",
6877 "staleObjects",
6878 ];
6879
6880 #[allow(clippy::enum_variant_names)]
6881 enum GeneratedField {
6882 Version,
6883 StaleObjects,
6884 }
6885 impl<'de> serde::Deserialize<'de> for GeneratedField {
6886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6887 where
6888 D: serde::Deserializer<'de>,
6889 {
6890 struct GeneratedVisitor;
6891
6892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6893 type Value = GeneratedField;
6894
6895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6896 write!(formatter, "expected one of: {:?}", &FIELDS)
6897 }
6898
6899 #[allow(unused_variables)]
6900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6901 where
6902 E: serde::de::Error,
6903 {
6904 match value {
6905 "version" => Ok(GeneratedField::Version),
6906 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
6907 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6908 }
6909 }
6910 }
6911 deserializer.deserialize_identifier(GeneratedVisitor)
6912 }
6913 }
6914 struct GeneratedVisitor;
6915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6916 type Value = HummockVersionCheckpoint;
6917
6918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6919 formatter.write_str("struct hummock.HummockVersionCheckpoint")
6920 }
6921
6922 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
6923 where
6924 V: serde::de::MapAccess<'de>,
6925 {
6926 let mut version__ = None;
6927 let mut stale_objects__ = None;
6928 while let Some(k) = map_.next_key()? {
6929 match k {
6930 GeneratedField::Version => {
6931 if version__.is_some() {
6932 return Err(serde::de::Error::duplicate_field("version"));
6933 }
6934 version__ = map_.next_value()?;
6935 }
6936 GeneratedField::StaleObjects => {
6937 if stale_objects__.is_some() {
6938 return Err(serde::de::Error::duplicate_field("staleObjects"));
6939 }
6940 stale_objects__ = Some(
6941 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6942 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6943 );
6944 }
6945 }
6946 }
6947 Ok(HummockVersionCheckpoint {
6948 version: version__,
6949 stale_objects: stale_objects__.unwrap_or_default(),
6950 })
6951 }
6952 }
6953 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
6954 }
6955}
6956impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
6957 #[allow(deprecated)]
6958 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6959 where
6960 S: serde::Serializer,
6961 {
6962 use serde::ser::SerializeStruct;
6963 let mut len = 0;
6964 if !self.id.is_empty() {
6965 len += 1;
6966 }
6967 if self.total_file_size != 0 {
6968 len += 1;
6969 }
6970 if !self.vector_files.is_empty() {
6971 len += 1;
6972 }
6973 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
6974 if !self.id.is_empty() {
6975 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
6976 }
6977 if self.total_file_size != 0 {
6978 #[allow(clippy::needless_borrow)]
6979 #[allow(clippy::needless_borrows_for_generic_args)]
6980 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
6981 }
6982 if !self.vector_files.is_empty() {
6983 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
6984 }
6985 struct_ser.end()
6986 }
6987}
6988impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
6989 #[allow(deprecated)]
6990 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6991 where
6992 D: serde::Deserializer<'de>,
6993 {
6994 const FIELDS: &[&str] = &[
6995 "id",
6996 "total_file_size",
6997 "totalFileSize",
6998 "vector_files",
6999 "vectorFiles",
7000 ];
7001
7002 #[allow(clippy::enum_variant_names)]
7003 enum GeneratedField {
7004 Id,
7005 TotalFileSize,
7006 VectorFiles,
7007 }
7008 impl<'de> serde::Deserialize<'de> for GeneratedField {
7009 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7010 where
7011 D: serde::Deserializer<'de>,
7012 {
7013 struct GeneratedVisitor;
7014
7015 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7016 type Value = GeneratedField;
7017
7018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7019 write!(formatter, "expected one of: {:?}", &FIELDS)
7020 }
7021
7022 #[allow(unused_variables)]
7023 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7024 where
7025 E: serde::de::Error,
7026 {
7027 match value {
7028 "id" => Ok(GeneratedField::Id),
7029 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7030 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
7031 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7032 }
7033 }
7034 }
7035 deserializer.deserialize_identifier(GeneratedVisitor)
7036 }
7037 }
7038 struct GeneratedVisitor;
7039 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7040 type Value = hummock_version_checkpoint::StaleObjects;
7041
7042 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7043 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
7044 }
7045
7046 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
7047 where
7048 V: serde::de::MapAccess<'de>,
7049 {
7050 let mut id__ = None;
7051 let mut total_file_size__ = None;
7052 let mut vector_files__ = None;
7053 while let Some(k) = map_.next_key()? {
7054 match k {
7055 GeneratedField::Id => {
7056 if id__.is_some() {
7057 return Err(serde::de::Error::duplicate_field("id"));
7058 }
7059 id__ =
7060 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7061 .into_iter().map(|x| x.0).collect())
7062 ;
7063 }
7064 GeneratedField::TotalFileSize => {
7065 if total_file_size__.is_some() {
7066 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7067 }
7068 total_file_size__ =
7069 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7070 ;
7071 }
7072 GeneratedField::VectorFiles => {
7073 if vector_files__.is_some() {
7074 return Err(serde::de::Error::duplicate_field("vectorFiles"));
7075 }
7076 vector_files__ = Some(map_.next_value()?);
7077 }
7078 }
7079 }
7080 Ok(hummock_version_checkpoint::StaleObjects {
7081 id: id__.unwrap_or_default(),
7082 total_file_size: total_file_size__.unwrap_or_default(),
7083 vector_files: vector_files__.unwrap_or_default(),
7084 })
7085 }
7086 }
7087 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
7088 }
7089}
7090impl serde::Serialize for HummockVersionDelta {
7091 #[allow(deprecated)]
7092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7093 where
7094 S: serde::Serializer,
7095 {
7096 use serde::ser::SerializeStruct;
7097 let mut len = 0;
7098 if self.id != 0 {
7099 len += 1;
7100 }
7101 if self.prev_id != 0 {
7102 len += 1;
7103 }
7104 if !self.group_deltas.is_empty() {
7105 len += 1;
7106 }
7107 if self.max_committed_epoch != 0 {
7108 len += 1;
7109 }
7110 if self.trivial_move {
7111 len += 1;
7112 }
7113 if !self.new_table_watermarks.is_empty() {
7114 len += 1;
7115 }
7116 if !self.removed_table_ids.is_empty() {
7117 len += 1;
7118 }
7119 if !self.change_log_delta.is_empty() {
7120 len += 1;
7121 }
7122 if !self.state_table_info_delta.is_empty() {
7123 len += 1;
7124 }
7125 if !self.vector_index_delta.is_empty() {
7126 len += 1;
7127 }
7128 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
7129 if self.id != 0 {
7130 #[allow(clippy::needless_borrow)]
7131 #[allow(clippy::needless_borrows_for_generic_args)]
7132 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7133 }
7134 if self.prev_id != 0 {
7135 #[allow(clippy::needless_borrow)]
7136 #[allow(clippy::needless_borrows_for_generic_args)]
7137 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
7138 }
7139 if !self.group_deltas.is_empty() {
7140 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7141 }
7142 if self.max_committed_epoch != 0 {
7143 #[allow(clippy::needless_borrow)]
7144 #[allow(clippy::needless_borrows_for_generic_args)]
7145 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
7146 }
7147 if self.trivial_move {
7148 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
7149 }
7150 if !self.new_table_watermarks.is_empty() {
7151 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
7152 }
7153 if !self.removed_table_ids.is_empty() {
7154 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
7155 }
7156 if !self.change_log_delta.is_empty() {
7157 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
7158 }
7159 if !self.state_table_info_delta.is_empty() {
7160 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
7161 }
7162 if !self.vector_index_delta.is_empty() {
7163 struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
7164 }
7165 struct_ser.end()
7166 }
7167}
7168impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
7169 #[allow(deprecated)]
7170 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7171 where
7172 D: serde::Deserializer<'de>,
7173 {
7174 const FIELDS: &[&str] = &[
7175 "id",
7176 "prev_id",
7177 "prevId",
7178 "group_deltas",
7179 "groupDeltas",
7180 "max_committed_epoch",
7181 "maxCommittedEpoch",
7182 "trivial_move",
7183 "trivialMove",
7184 "new_table_watermarks",
7185 "newTableWatermarks",
7186 "removed_table_ids",
7187 "removedTableIds",
7188 "change_log_delta",
7189 "changeLogDelta",
7190 "state_table_info_delta",
7191 "stateTableInfoDelta",
7192 "vector_index_delta",
7193 "vectorIndexDelta",
7194 ];
7195
7196 #[allow(clippy::enum_variant_names)]
7197 enum GeneratedField {
7198 Id,
7199 PrevId,
7200 GroupDeltas,
7201 MaxCommittedEpoch,
7202 TrivialMove,
7203 NewTableWatermarks,
7204 RemovedTableIds,
7205 ChangeLogDelta,
7206 StateTableInfoDelta,
7207 VectorIndexDelta,
7208 }
7209 impl<'de> serde::Deserialize<'de> for GeneratedField {
7210 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7211 where
7212 D: serde::Deserializer<'de>,
7213 {
7214 struct GeneratedVisitor;
7215
7216 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7217 type Value = GeneratedField;
7218
7219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7220 write!(formatter, "expected one of: {:?}", &FIELDS)
7221 }
7222
7223 #[allow(unused_variables)]
7224 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7225 where
7226 E: serde::de::Error,
7227 {
7228 match value {
7229 "id" => Ok(GeneratedField::Id),
7230 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
7231 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
7232 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
7233 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
7234 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
7235 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7236 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
7237 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
7238 "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
7239 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7240 }
7241 }
7242 }
7243 deserializer.deserialize_identifier(GeneratedVisitor)
7244 }
7245 }
7246 struct GeneratedVisitor;
7247 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7248 type Value = HummockVersionDelta;
7249
7250 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7251 formatter.write_str("struct hummock.HummockVersionDelta")
7252 }
7253
7254 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
7255 where
7256 V: serde::de::MapAccess<'de>,
7257 {
7258 let mut id__ = None;
7259 let mut prev_id__ = None;
7260 let mut group_deltas__ = None;
7261 let mut max_committed_epoch__ = None;
7262 let mut trivial_move__ = None;
7263 let mut new_table_watermarks__ = None;
7264 let mut removed_table_ids__ = None;
7265 let mut change_log_delta__ = None;
7266 let mut state_table_info_delta__ = None;
7267 let mut vector_index_delta__ = None;
7268 while let Some(k) = map_.next_key()? {
7269 match k {
7270 GeneratedField::Id => {
7271 if id__.is_some() {
7272 return Err(serde::de::Error::duplicate_field("id"));
7273 }
7274 id__ =
7275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7276 ;
7277 }
7278 GeneratedField::PrevId => {
7279 if prev_id__.is_some() {
7280 return Err(serde::de::Error::duplicate_field("prevId"));
7281 }
7282 prev_id__ =
7283 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7284 ;
7285 }
7286 GeneratedField::GroupDeltas => {
7287 if group_deltas__.is_some() {
7288 return Err(serde::de::Error::duplicate_field("groupDeltas"));
7289 }
7290 group_deltas__ = Some(
7291 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7292 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7293 );
7294 }
7295 GeneratedField::MaxCommittedEpoch => {
7296 if max_committed_epoch__.is_some() {
7297 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
7298 }
7299 max_committed_epoch__ =
7300 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7301 ;
7302 }
7303 GeneratedField::TrivialMove => {
7304 if trivial_move__.is_some() {
7305 return Err(serde::de::Error::duplicate_field("trivialMove"));
7306 }
7307 trivial_move__ = Some(map_.next_value()?);
7308 }
7309 GeneratedField::NewTableWatermarks => {
7310 if new_table_watermarks__.is_some() {
7311 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
7312 }
7313 new_table_watermarks__ = Some(
7314 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7315 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7316 );
7317 }
7318 GeneratedField::RemovedTableIds => {
7319 if removed_table_ids__.is_some() {
7320 return Err(serde::de::Error::duplicate_field("removedTableIds"));
7321 }
7322 removed_table_ids__ =
7323 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7324 .into_iter().map(|x| x.0).collect())
7325 ;
7326 }
7327 GeneratedField::ChangeLogDelta => {
7328 if change_log_delta__.is_some() {
7329 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
7330 }
7331 change_log_delta__ = Some(
7332 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7333 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7334 );
7335 }
7336 GeneratedField::StateTableInfoDelta => {
7337 if state_table_info_delta__.is_some() {
7338 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
7339 }
7340 state_table_info_delta__ = Some(
7341 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7342 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7343 );
7344 }
7345 GeneratedField::VectorIndexDelta => {
7346 if vector_index_delta__.is_some() {
7347 return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
7348 }
7349 vector_index_delta__ = Some(
7350 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7351 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7352 );
7353 }
7354 }
7355 }
7356 Ok(HummockVersionDelta {
7357 id: id__.unwrap_or_default(),
7358 prev_id: prev_id__.unwrap_or_default(),
7359 group_deltas: group_deltas__.unwrap_or_default(),
7360 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
7361 trivial_move: trivial_move__.unwrap_or_default(),
7362 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
7363 removed_table_ids: removed_table_ids__.unwrap_or_default(),
7364 change_log_delta: change_log_delta__.unwrap_or_default(),
7365 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
7366 vector_index_delta: vector_index_delta__.unwrap_or_default(),
7367 })
7368 }
7369 }
7370 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
7371 }
7372}
7373impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
7374 #[allow(deprecated)]
7375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7376 where
7377 S: serde::Serializer,
7378 {
7379 use serde::ser::SerializeStruct;
7380 let mut len = 0;
7381 if self.new_log.is_some() {
7382 len += 1;
7383 }
7384 if self.truncate_epoch != 0 {
7385 len += 1;
7386 }
7387 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
7388 if let Some(v) = self.new_log.as_ref() {
7389 struct_ser.serialize_field("newLog", v)?;
7390 }
7391 if self.truncate_epoch != 0 {
7392 #[allow(clippy::needless_borrow)]
7393 #[allow(clippy::needless_borrows_for_generic_args)]
7394 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
7395 }
7396 struct_ser.end()
7397 }
7398}
7399impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
7400 #[allow(deprecated)]
7401 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7402 where
7403 D: serde::Deserializer<'de>,
7404 {
7405 const FIELDS: &[&str] = &[
7406 "new_log",
7407 "newLog",
7408 "truncate_epoch",
7409 "truncateEpoch",
7410 ];
7411
7412 #[allow(clippy::enum_variant_names)]
7413 enum GeneratedField {
7414 NewLog,
7415 TruncateEpoch,
7416 }
7417 impl<'de> serde::Deserialize<'de> for GeneratedField {
7418 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7419 where
7420 D: serde::Deserializer<'de>,
7421 {
7422 struct GeneratedVisitor;
7423
7424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7425 type Value = GeneratedField;
7426
7427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7428 write!(formatter, "expected one of: {:?}", &FIELDS)
7429 }
7430
7431 #[allow(unused_variables)]
7432 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7433 where
7434 E: serde::de::Error,
7435 {
7436 match value {
7437 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
7438 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
7439 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7440 }
7441 }
7442 }
7443 deserializer.deserialize_identifier(GeneratedVisitor)
7444 }
7445 }
7446 struct GeneratedVisitor;
7447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7448 type Value = hummock_version_delta::ChangeLogDelta;
7449
7450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7451 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
7452 }
7453
7454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
7455 where
7456 V: serde::de::MapAccess<'de>,
7457 {
7458 let mut new_log__ = None;
7459 let mut truncate_epoch__ = None;
7460 while let Some(k) = map_.next_key()? {
7461 match k {
7462 GeneratedField::NewLog => {
7463 if new_log__.is_some() {
7464 return Err(serde::de::Error::duplicate_field("newLog"));
7465 }
7466 new_log__ = map_.next_value()?;
7467 }
7468 GeneratedField::TruncateEpoch => {
7469 if truncate_epoch__.is_some() {
7470 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
7471 }
7472 truncate_epoch__ =
7473 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7474 ;
7475 }
7476 }
7477 }
7478 Ok(hummock_version_delta::ChangeLogDelta {
7479 new_log: new_log__,
7480 truncate_epoch: truncate_epoch__.unwrap_or_default(),
7481 })
7482 }
7483 }
7484 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
7485 }
7486}
7487impl serde::Serialize for hummock_version_delta::GroupDeltas {
7488 #[allow(deprecated)]
7489 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7490 where
7491 S: serde::Serializer,
7492 {
7493 use serde::ser::SerializeStruct;
7494 let mut len = 0;
7495 if !self.group_deltas.is_empty() {
7496 len += 1;
7497 }
7498 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
7499 if !self.group_deltas.is_empty() {
7500 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7501 }
7502 struct_ser.end()
7503 }
7504}
7505impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
7506 #[allow(deprecated)]
7507 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7508 where
7509 D: serde::Deserializer<'de>,
7510 {
7511 const FIELDS: &[&str] = &[
7512 "group_deltas",
7513 "groupDeltas",
7514 ];
7515
7516 #[allow(clippy::enum_variant_names)]
7517 enum GeneratedField {
7518 GroupDeltas,
7519 }
7520 impl<'de> serde::Deserialize<'de> for GeneratedField {
7521 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7522 where
7523 D: serde::Deserializer<'de>,
7524 {
7525 struct GeneratedVisitor;
7526
7527 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7528 type Value = GeneratedField;
7529
7530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7531 write!(formatter, "expected one of: {:?}", &FIELDS)
7532 }
7533
7534 #[allow(unused_variables)]
7535 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7536 where
7537 E: serde::de::Error,
7538 {
7539 match value {
7540 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
7541 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7542 }
7543 }
7544 }
7545 deserializer.deserialize_identifier(GeneratedVisitor)
7546 }
7547 }
7548 struct GeneratedVisitor;
7549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7550 type Value = hummock_version_delta::GroupDeltas;
7551
7552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7553 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
7554 }
7555
7556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
7557 where
7558 V: serde::de::MapAccess<'de>,
7559 {
7560 let mut group_deltas__ = None;
7561 while let Some(k) = map_.next_key()? {
7562 match k {
7563 GeneratedField::GroupDeltas => {
7564 if group_deltas__.is_some() {
7565 return Err(serde::de::Error::duplicate_field("groupDeltas"));
7566 }
7567 group_deltas__ = Some(map_.next_value()?);
7568 }
7569 }
7570 }
7571 Ok(hummock_version_delta::GroupDeltas {
7572 group_deltas: group_deltas__.unwrap_or_default(),
7573 })
7574 }
7575 }
7576 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
7577 }
7578}
7579impl serde::Serialize for HummockVersionDeltas {
7580 #[allow(deprecated)]
7581 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7582 where
7583 S: serde::Serializer,
7584 {
7585 use serde::ser::SerializeStruct;
7586 let mut len = 0;
7587 if !self.version_deltas.is_empty() {
7588 len += 1;
7589 }
7590 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
7591 if !self.version_deltas.is_empty() {
7592 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
7593 }
7594 struct_ser.end()
7595 }
7596}
7597impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
7598 #[allow(deprecated)]
7599 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7600 where
7601 D: serde::Deserializer<'de>,
7602 {
7603 const FIELDS: &[&str] = &[
7604 "version_deltas",
7605 "versionDeltas",
7606 ];
7607
7608 #[allow(clippy::enum_variant_names)]
7609 enum GeneratedField {
7610 VersionDeltas,
7611 }
7612 impl<'de> serde::Deserialize<'de> for GeneratedField {
7613 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7614 where
7615 D: serde::Deserializer<'de>,
7616 {
7617 struct GeneratedVisitor;
7618
7619 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7620 type Value = GeneratedField;
7621
7622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7623 write!(formatter, "expected one of: {:?}", &FIELDS)
7624 }
7625
7626 #[allow(unused_variables)]
7627 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7628 where
7629 E: serde::de::Error,
7630 {
7631 match value {
7632 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
7633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7634 }
7635 }
7636 }
7637 deserializer.deserialize_identifier(GeneratedVisitor)
7638 }
7639 }
7640 struct GeneratedVisitor;
7641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7642 type Value = HummockVersionDeltas;
7643
7644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7645 formatter.write_str("struct hummock.HummockVersionDeltas")
7646 }
7647
7648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
7649 where
7650 V: serde::de::MapAccess<'de>,
7651 {
7652 let mut version_deltas__ = None;
7653 while let Some(k) = map_.next_key()? {
7654 match k {
7655 GeneratedField::VersionDeltas => {
7656 if version_deltas__.is_some() {
7657 return Err(serde::de::Error::duplicate_field("versionDeltas"));
7658 }
7659 version_deltas__ = Some(map_.next_value()?);
7660 }
7661 }
7662 }
7663 Ok(HummockVersionDeltas {
7664 version_deltas: version_deltas__.unwrap_or_default(),
7665 })
7666 }
7667 }
7668 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
7669 }
7670}
7671impl serde::Serialize for HummockVersionStats {
7672 #[allow(deprecated)]
7673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7674 where
7675 S: serde::Serializer,
7676 {
7677 use serde::ser::SerializeStruct;
7678 let mut len = 0;
7679 if self.hummock_version_id != 0 {
7680 len += 1;
7681 }
7682 if !self.table_stats.is_empty() {
7683 len += 1;
7684 }
7685 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
7686 if self.hummock_version_id != 0 {
7687 #[allow(clippy::needless_borrow)]
7688 #[allow(clippy::needless_borrows_for_generic_args)]
7689 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
7690 }
7691 if !self.table_stats.is_empty() {
7692 struct_ser.serialize_field("tableStats", &self.table_stats)?;
7693 }
7694 struct_ser.end()
7695 }
7696}
7697impl<'de> serde::Deserialize<'de> for HummockVersionStats {
7698 #[allow(deprecated)]
7699 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7700 where
7701 D: serde::Deserializer<'de>,
7702 {
7703 const FIELDS: &[&str] = &[
7704 "hummock_version_id",
7705 "hummockVersionId",
7706 "table_stats",
7707 "tableStats",
7708 ];
7709
7710 #[allow(clippy::enum_variant_names)]
7711 enum GeneratedField {
7712 HummockVersionId,
7713 TableStats,
7714 }
7715 impl<'de> serde::Deserialize<'de> for GeneratedField {
7716 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7717 where
7718 D: serde::Deserializer<'de>,
7719 {
7720 struct GeneratedVisitor;
7721
7722 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7723 type Value = GeneratedField;
7724
7725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7726 write!(formatter, "expected one of: {:?}", &FIELDS)
7727 }
7728
7729 #[allow(unused_variables)]
7730 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7731 where
7732 E: serde::de::Error,
7733 {
7734 match value {
7735 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
7736 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
7737 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7738 }
7739 }
7740 }
7741 deserializer.deserialize_identifier(GeneratedVisitor)
7742 }
7743 }
7744 struct GeneratedVisitor;
7745 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7746 type Value = HummockVersionStats;
7747
7748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7749 formatter.write_str("struct hummock.HummockVersionStats")
7750 }
7751
7752 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
7753 where
7754 V: serde::de::MapAccess<'de>,
7755 {
7756 let mut hummock_version_id__ = None;
7757 let mut table_stats__ = None;
7758 while let Some(k) = map_.next_key()? {
7759 match k {
7760 GeneratedField::HummockVersionId => {
7761 if hummock_version_id__.is_some() {
7762 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
7763 }
7764 hummock_version_id__ =
7765 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7766 ;
7767 }
7768 GeneratedField::TableStats => {
7769 if table_stats__.is_some() {
7770 return Err(serde::de::Error::duplicate_field("tableStats"));
7771 }
7772 table_stats__ = Some(
7773 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7774 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7775 );
7776 }
7777 }
7778 }
7779 Ok(HummockVersionStats {
7780 hummock_version_id: hummock_version_id__.unwrap_or_default(),
7781 table_stats: table_stats__.unwrap_or_default(),
7782 })
7783 }
7784 }
7785 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
7786 }
7787}
7788impl serde::Serialize for InitMetadataForReplayRequest {
7789 #[allow(deprecated)]
7790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7791 where
7792 S: serde::Serializer,
7793 {
7794 use serde::ser::SerializeStruct;
7795 let mut len = 0;
7796 if !self.tables.is_empty() {
7797 len += 1;
7798 }
7799 if !self.compaction_groups.is_empty() {
7800 len += 1;
7801 }
7802 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
7803 if !self.tables.is_empty() {
7804 struct_ser.serialize_field("tables", &self.tables)?;
7805 }
7806 if !self.compaction_groups.is_empty() {
7807 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
7808 }
7809 struct_ser.end()
7810 }
7811}
7812impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
7813 #[allow(deprecated)]
7814 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7815 where
7816 D: serde::Deserializer<'de>,
7817 {
7818 const FIELDS: &[&str] = &[
7819 "tables",
7820 "compaction_groups",
7821 "compactionGroups",
7822 ];
7823
7824 #[allow(clippy::enum_variant_names)]
7825 enum GeneratedField {
7826 Tables,
7827 CompactionGroups,
7828 }
7829 impl<'de> serde::Deserialize<'de> for GeneratedField {
7830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7831 where
7832 D: serde::Deserializer<'de>,
7833 {
7834 struct GeneratedVisitor;
7835
7836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7837 type Value = GeneratedField;
7838
7839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7840 write!(formatter, "expected one of: {:?}", &FIELDS)
7841 }
7842
7843 #[allow(unused_variables)]
7844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7845 where
7846 E: serde::de::Error,
7847 {
7848 match value {
7849 "tables" => Ok(GeneratedField::Tables),
7850 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
7851 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7852 }
7853 }
7854 }
7855 deserializer.deserialize_identifier(GeneratedVisitor)
7856 }
7857 }
7858 struct GeneratedVisitor;
7859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7860 type Value = InitMetadataForReplayRequest;
7861
7862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7863 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
7864 }
7865
7866 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
7867 where
7868 V: serde::de::MapAccess<'de>,
7869 {
7870 let mut tables__ = None;
7871 let mut compaction_groups__ = None;
7872 while let Some(k) = map_.next_key()? {
7873 match k {
7874 GeneratedField::Tables => {
7875 if tables__.is_some() {
7876 return Err(serde::de::Error::duplicate_field("tables"));
7877 }
7878 tables__ = Some(map_.next_value()?);
7879 }
7880 GeneratedField::CompactionGroups => {
7881 if compaction_groups__.is_some() {
7882 return Err(serde::de::Error::duplicate_field("compactionGroups"));
7883 }
7884 compaction_groups__ = Some(map_.next_value()?);
7885 }
7886 }
7887 }
7888 Ok(InitMetadataForReplayRequest {
7889 tables: tables__.unwrap_or_default(),
7890 compaction_groups: compaction_groups__.unwrap_or_default(),
7891 })
7892 }
7893 }
7894 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
7895 }
7896}
7897impl serde::Serialize for InitMetadataForReplayResponse {
7898 #[allow(deprecated)]
7899 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7900 where
7901 S: serde::Serializer,
7902 {
7903 use serde::ser::SerializeStruct;
7904 let len = 0;
7905 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
7906 struct_ser.end()
7907 }
7908}
7909impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
7910 #[allow(deprecated)]
7911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7912 where
7913 D: serde::Deserializer<'de>,
7914 {
7915 const FIELDS: &[&str] = &[
7916 ];
7917
7918 #[allow(clippy::enum_variant_names)]
7919 enum GeneratedField {
7920 }
7921 impl<'de> serde::Deserialize<'de> for GeneratedField {
7922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7923 where
7924 D: serde::Deserializer<'de>,
7925 {
7926 struct GeneratedVisitor;
7927
7928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7929 type Value = GeneratedField;
7930
7931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7932 write!(formatter, "expected one of: {:?}", &FIELDS)
7933 }
7934
7935 #[allow(unused_variables)]
7936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7937 where
7938 E: serde::de::Error,
7939 {
7940 Err(serde::de::Error::unknown_field(value, FIELDS))
7941 }
7942 }
7943 deserializer.deserialize_identifier(GeneratedVisitor)
7944 }
7945 }
7946 struct GeneratedVisitor;
7947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7948 type Value = InitMetadataForReplayResponse;
7949
7950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7951 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
7952 }
7953
7954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
7955 where
7956 V: serde::de::MapAccess<'de>,
7957 {
7958 while map_.next_key::<GeneratedField>()?.is_some() {
7959 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7960 }
7961 Ok(InitMetadataForReplayResponse {
7962 })
7963 }
7964 }
7965 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
7966 }
7967}
7968impl serde::Serialize for InputLevel {
7969 #[allow(deprecated)]
7970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7971 where
7972 S: serde::Serializer,
7973 {
7974 use serde::ser::SerializeStruct;
7975 let mut len = 0;
7976 if self.level_idx != 0 {
7977 len += 1;
7978 }
7979 if self.level_type != 0 {
7980 len += 1;
7981 }
7982 if !self.table_infos.is_empty() {
7983 len += 1;
7984 }
7985 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
7986 if self.level_idx != 0 {
7987 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7988 }
7989 if self.level_type != 0 {
7990 let v = LevelType::try_from(self.level_type)
7991 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7992 struct_ser.serialize_field("levelType", &v)?;
7993 }
7994 if !self.table_infos.is_empty() {
7995 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7996 }
7997 struct_ser.end()
7998 }
7999}
8000impl<'de> serde::Deserialize<'de> for InputLevel {
8001 #[allow(deprecated)]
8002 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8003 where
8004 D: serde::Deserializer<'de>,
8005 {
8006 const FIELDS: &[&str] = &[
8007 "level_idx",
8008 "levelIdx",
8009 "level_type",
8010 "levelType",
8011 "table_infos",
8012 "tableInfos",
8013 ];
8014
8015 #[allow(clippy::enum_variant_names)]
8016 enum GeneratedField {
8017 LevelIdx,
8018 LevelType,
8019 TableInfos,
8020 }
8021 impl<'de> serde::Deserialize<'de> for GeneratedField {
8022 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8023 where
8024 D: serde::Deserializer<'de>,
8025 {
8026 struct GeneratedVisitor;
8027
8028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8029 type Value = GeneratedField;
8030
8031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8032 write!(formatter, "expected one of: {:?}", &FIELDS)
8033 }
8034
8035 #[allow(unused_variables)]
8036 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8037 where
8038 E: serde::de::Error,
8039 {
8040 match value {
8041 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8042 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8043 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8044 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8045 }
8046 }
8047 }
8048 deserializer.deserialize_identifier(GeneratedVisitor)
8049 }
8050 }
8051 struct GeneratedVisitor;
8052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8053 type Value = InputLevel;
8054
8055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8056 formatter.write_str("struct hummock.InputLevel")
8057 }
8058
8059 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
8060 where
8061 V: serde::de::MapAccess<'de>,
8062 {
8063 let mut level_idx__ = None;
8064 let mut level_type__ = None;
8065 let mut table_infos__ = None;
8066 while let Some(k) = map_.next_key()? {
8067 match k {
8068 GeneratedField::LevelIdx => {
8069 if level_idx__.is_some() {
8070 return Err(serde::de::Error::duplicate_field("levelIdx"));
8071 }
8072 level_idx__ =
8073 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8074 ;
8075 }
8076 GeneratedField::LevelType => {
8077 if level_type__.is_some() {
8078 return Err(serde::de::Error::duplicate_field("levelType"));
8079 }
8080 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8081 }
8082 GeneratedField::TableInfos => {
8083 if table_infos__.is_some() {
8084 return Err(serde::de::Error::duplicate_field("tableInfos"));
8085 }
8086 table_infos__ = Some(map_.next_value()?);
8087 }
8088 }
8089 }
8090 Ok(InputLevel {
8091 level_idx: level_idx__.unwrap_or_default(),
8092 level_type: level_type__.unwrap_or_default(),
8093 table_infos: table_infos__.unwrap_or_default(),
8094 })
8095 }
8096 }
8097 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
8098 }
8099}
8100impl serde::Serialize for IntraLevelDelta {
8101 #[allow(deprecated)]
8102 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8103 where
8104 S: serde::Serializer,
8105 {
8106 use serde::ser::SerializeStruct;
8107 let mut len = 0;
8108 if self.level_idx != 0 {
8109 len += 1;
8110 }
8111 if self.l0_sub_level_id != 0 {
8112 len += 1;
8113 }
8114 if !self.removed_table_ids.is_empty() {
8115 len += 1;
8116 }
8117 if !self.inserted_table_infos.is_empty() {
8118 len += 1;
8119 }
8120 if self.vnode_partition_count != 0 {
8121 len += 1;
8122 }
8123 if self.compaction_group_version_id != 0 {
8124 len += 1;
8125 }
8126 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
8127 if self.level_idx != 0 {
8128 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8129 }
8130 if self.l0_sub_level_id != 0 {
8131 #[allow(clippy::needless_borrow)]
8132 #[allow(clippy::needless_borrows_for_generic_args)]
8133 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
8134 }
8135 if !self.removed_table_ids.is_empty() {
8136 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8137 }
8138 if !self.inserted_table_infos.is_empty() {
8139 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
8140 }
8141 if self.vnode_partition_count != 0 {
8142 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8143 }
8144 if self.compaction_group_version_id != 0 {
8145 #[allow(clippy::needless_borrow)]
8146 #[allow(clippy::needless_borrows_for_generic_args)]
8147 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
8148 }
8149 struct_ser.end()
8150 }
8151}
8152impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
8153 #[allow(deprecated)]
8154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8155 where
8156 D: serde::Deserializer<'de>,
8157 {
8158 const FIELDS: &[&str] = &[
8159 "level_idx",
8160 "levelIdx",
8161 "l0_sub_level_id",
8162 "l0SubLevelId",
8163 "removed_table_ids",
8164 "removedTableIds",
8165 "inserted_table_infos",
8166 "insertedTableInfos",
8167 "vnode_partition_count",
8168 "vnodePartitionCount",
8169 "compaction_group_version_id",
8170 "compactionGroupVersionId",
8171 ];
8172
8173 #[allow(clippy::enum_variant_names)]
8174 enum GeneratedField {
8175 LevelIdx,
8176 L0SubLevelId,
8177 RemovedTableIds,
8178 InsertedTableInfos,
8179 VnodePartitionCount,
8180 CompactionGroupVersionId,
8181 }
8182 impl<'de> serde::Deserialize<'de> for GeneratedField {
8183 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8184 where
8185 D: serde::Deserializer<'de>,
8186 {
8187 struct GeneratedVisitor;
8188
8189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8190 type Value = GeneratedField;
8191
8192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8193 write!(formatter, "expected one of: {:?}", &FIELDS)
8194 }
8195
8196 #[allow(unused_variables)]
8197 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8198 where
8199 E: serde::de::Error,
8200 {
8201 match value {
8202 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8203 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
8204 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
8205 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
8206 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8207 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
8208 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8209 }
8210 }
8211 }
8212 deserializer.deserialize_identifier(GeneratedVisitor)
8213 }
8214 }
8215 struct GeneratedVisitor;
8216 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8217 type Value = IntraLevelDelta;
8218
8219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8220 formatter.write_str("struct hummock.IntraLevelDelta")
8221 }
8222
8223 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
8224 where
8225 V: serde::de::MapAccess<'de>,
8226 {
8227 let mut level_idx__ = None;
8228 let mut l0_sub_level_id__ = None;
8229 let mut removed_table_ids__ = None;
8230 let mut inserted_table_infos__ = None;
8231 let mut vnode_partition_count__ = None;
8232 let mut compaction_group_version_id__ = None;
8233 while let Some(k) = map_.next_key()? {
8234 match k {
8235 GeneratedField::LevelIdx => {
8236 if level_idx__.is_some() {
8237 return Err(serde::de::Error::duplicate_field("levelIdx"));
8238 }
8239 level_idx__ =
8240 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8241 ;
8242 }
8243 GeneratedField::L0SubLevelId => {
8244 if l0_sub_level_id__.is_some() {
8245 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
8246 }
8247 l0_sub_level_id__ =
8248 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8249 ;
8250 }
8251 GeneratedField::RemovedTableIds => {
8252 if removed_table_ids__.is_some() {
8253 return Err(serde::de::Error::duplicate_field("removedTableIds"));
8254 }
8255 removed_table_ids__ =
8256 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8257 .into_iter().map(|x| x.0).collect())
8258 ;
8259 }
8260 GeneratedField::InsertedTableInfos => {
8261 if inserted_table_infos__.is_some() {
8262 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
8263 }
8264 inserted_table_infos__ = Some(map_.next_value()?);
8265 }
8266 GeneratedField::VnodePartitionCount => {
8267 if vnode_partition_count__.is_some() {
8268 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
8269 }
8270 vnode_partition_count__ =
8271 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8272 ;
8273 }
8274 GeneratedField::CompactionGroupVersionId => {
8275 if compaction_group_version_id__.is_some() {
8276 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
8277 }
8278 compaction_group_version_id__ =
8279 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8280 ;
8281 }
8282 }
8283 }
8284 Ok(IntraLevelDelta {
8285 level_idx: level_idx__.unwrap_or_default(),
8286 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
8287 removed_table_ids: removed_table_ids__.unwrap_or_default(),
8288 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
8289 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
8290 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
8291 })
8292 }
8293 }
8294 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
8295 }
8296}
8297impl serde::Serialize for KeyRange {
8298 #[allow(deprecated)]
8299 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8300 where
8301 S: serde::Serializer,
8302 {
8303 use serde::ser::SerializeStruct;
8304 let mut len = 0;
8305 if !self.left.is_empty() {
8306 len += 1;
8307 }
8308 if !self.right.is_empty() {
8309 len += 1;
8310 }
8311 if self.right_exclusive {
8312 len += 1;
8313 }
8314 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
8315 if !self.left.is_empty() {
8316 #[allow(clippy::needless_borrow)]
8317 #[allow(clippy::needless_borrows_for_generic_args)]
8318 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
8319 }
8320 if !self.right.is_empty() {
8321 #[allow(clippy::needless_borrow)]
8322 #[allow(clippy::needless_borrows_for_generic_args)]
8323 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
8324 }
8325 if self.right_exclusive {
8326 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
8327 }
8328 struct_ser.end()
8329 }
8330}
8331impl<'de> serde::Deserialize<'de> for KeyRange {
8332 #[allow(deprecated)]
8333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8334 where
8335 D: serde::Deserializer<'de>,
8336 {
8337 const FIELDS: &[&str] = &[
8338 "left",
8339 "right",
8340 "right_exclusive",
8341 "rightExclusive",
8342 ];
8343
8344 #[allow(clippy::enum_variant_names)]
8345 enum GeneratedField {
8346 Left,
8347 Right,
8348 RightExclusive,
8349 }
8350 impl<'de> serde::Deserialize<'de> for GeneratedField {
8351 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8352 where
8353 D: serde::Deserializer<'de>,
8354 {
8355 struct GeneratedVisitor;
8356
8357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8358 type Value = GeneratedField;
8359
8360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8361 write!(formatter, "expected one of: {:?}", &FIELDS)
8362 }
8363
8364 #[allow(unused_variables)]
8365 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8366 where
8367 E: serde::de::Error,
8368 {
8369 match value {
8370 "left" => Ok(GeneratedField::Left),
8371 "right" => Ok(GeneratedField::Right),
8372 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
8373 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8374 }
8375 }
8376 }
8377 deserializer.deserialize_identifier(GeneratedVisitor)
8378 }
8379 }
8380 struct GeneratedVisitor;
8381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8382 type Value = KeyRange;
8383
8384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8385 formatter.write_str("struct hummock.KeyRange")
8386 }
8387
8388 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
8389 where
8390 V: serde::de::MapAccess<'de>,
8391 {
8392 let mut left__ = None;
8393 let mut right__ = None;
8394 let mut right_exclusive__ = None;
8395 while let Some(k) = map_.next_key()? {
8396 match k {
8397 GeneratedField::Left => {
8398 if left__.is_some() {
8399 return Err(serde::de::Error::duplicate_field("left"));
8400 }
8401 left__ =
8402 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
8403 ;
8404 }
8405 GeneratedField::Right => {
8406 if right__.is_some() {
8407 return Err(serde::de::Error::duplicate_field("right"));
8408 }
8409 right__ =
8410 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
8411 ;
8412 }
8413 GeneratedField::RightExclusive => {
8414 if right_exclusive__.is_some() {
8415 return Err(serde::de::Error::duplicate_field("rightExclusive"));
8416 }
8417 right_exclusive__ = Some(map_.next_value()?);
8418 }
8419 }
8420 }
8421 Ok(KeyRange {
8422 left: left__.unwrap_or_default(),
8423 right: right__.unwrap_or_default(),
8424 right_exclusive: right_exclusive__.unwrap_or_default(),
8425 })
8426 }
8427 }
8428 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
8429 }
8430}
8431impl serde::Serialize for Level {
8432 #[allow(deprecated)]
8433 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8434 where
8435 S: serde::Serializer,
8436 {
8437 use serde::ser::SerializeStruct;
8438 let mut len = 0;
8439 if self.level_idx != 0 {
8440 len += 1;
8441 }
8442 if self.level_type != 0 {
8443 len += 1;
8444 }
8445 if !self.table_infos.is_empty() {
8446 len += 1;
8447 }
8448 if self.total_file_size != 0 {
8449 len += 1;
8450 }
8451 if self.sub_level_id != 0 {
8452 len += 1;
8453 }
8454 if self.uncompressed_file_size != 0 {
8455 len += 1;
8456 }
8457 if self.vnode_partition_count != 0 {
8458 len += 1;
8459 }
8460 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
8461 if self.level_idx != 0 {
8462 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8463 }
8464 if self.level_type != 0 {
8465 let v = LevelType::try_from(self.level_type)
8466 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
8467 struct_ser.serialize_field("levelType", &v)?;
8468 }
8469 if !self.table_infos.is_empty() {
8470 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
8471 }
8472 if self.total_file_size != 0 {
8473 #[allow(clippy::needless_borrow)]
8474 #[allow(clippy::needless_borrows_for_generic_args)]
8475 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8476 }
8477 if self.sub_level_id != 0 {
8478 #[allow(clippy::needless_borrow)]
8479 #[allow(clippy::needless_borrows_for_generic_args)]
8480 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
8481 }
8482 if self.uncompressed_file_size != 0 {
8483 #[allow(clippy::needless_borrow)]
8484 #[allow(clippy::needless_borrows_for_generic_args)]
8485 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
8486 }
8487 if self.vnode_partition_count != 0 {
8488 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8489 }
8490 struct_ser.end()
8491 }
8492}
8493impl<'de> serde::Deserialize<'de> for Level {
8494 #[allow(deprecated)]
8495 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8496 where
8497 D: serde::Deserializer<'de>,
8498 {
8499 const FIELDS: &[&str] = &[
8500 "level_idx",
8501 "levelIdx",
8502 "level_type",
8503 "levelType",
8504 "table_infos",
8505 "tableInfos",
8506 "total_file_size",
8507 "totalFileSize",
8508 "sub_level_id",
8509 "subLevelId",
8510 "uncompressed_file_size",
8511 "uncompressedFileSize",
8512 "vnode_partition_count",
8513 "vnodePartitionCount",
8514 ];
8515
8516 #[allow(clippy::enum_variant_names)]
8517 enum GeneratedField {
8518 LevelIdx,
8519 LevelType,
8520 TableInfos,
8521 TotalFileSize,
8522 SubLevelId,
8523 UncompressedFileSize,
8524 VnodePartitionCount,
8525 }
8526 impl<'de> serde::Deserialize<'de> for GeneratedField {
8527 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8528 where
8529 D: serde::Deserializer<'de>,
8530 {
8531 struct GeneratedVisitor;
8532
8533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8534 type Value = GeneratedField;
8535
8536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8537 write!(formatter, "expected one of: {:?}", &FIELDS)
8538 }
8539
8540 #[allow(unused_variables)]
8541 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8542 where
8543 E: serde::de::Error,
8544 {
8545 match value {
8546 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8547 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8548 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8549 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8550 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
8551 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
8552 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8553 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8554 }
8555 }
8556 }
8557 deserializer.deserialize_identifier(GeneratedVisitor)
8558 }
8559 }
8560 struct GeneratedVisitor;
8561 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8562 type Value = Level;
8563
8564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8565 formatter.write_str("struct hummock.Level")
8566 }
8567
8568 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
8569 where
8570 V: serde::de::MapAccess<'de>,
8571 {
8572 let mut level_idx__ = None;
8573 let mut level_type__ = None;
8574 let mut table_infos__ = None;
8575 let mut total_file_size__ = None;
8576 let mut sub_level_id__ = None;
8577 let mut uncompressed_file_size__ = None;
8578 let mut vnode_partition_count__ = None;
8579 while let Some(k) = map_.next_key()? {
8580 match k {
8581 GeneratedField::LevelIdx => {
8582 if level_idx__.is_some() {
8583 return Err(serde::de::Error::duplicate_field("levelIdx"));
8584 }
8585 level_idx__ =
8586 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8587 ;
8588 }
8589 GeneratedField::LevelType => {
8590 if level_type__.is_some() {
8591 return Err(serde::de::Error::duplicate_field("levelType"));
8592 }
8593 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8594 }
8595 GeneratedField::TableInfos => {
8596 if table_infos__.is_some() {
8597 return Err(serde::de::Error::duplicate_field("tableInfos"));
8598 }
8599 table_infos__ = Some(map_.next_value()?);
8600 }
8601 GeneratedField::TotalFileSize => {
8602 if total_file_size__.is_some() {
8603 return Err(serde::de::Error::duplicate_field("totalFileSize"));
8604 }
8605 total_file_size__ =
8606 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8607 ;
8608 }
8609 GeneratedField::SubLevelId => {
8610 if sub_level_id__.is_some() {
8611 return Err(serde::de::Error::duplicate_field("subLevelId"));
8612 }
8613 sub_level_id__ =
8614 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8615 ;
8616 }
8617 GeneratedField::UncompressedFileSize => {
8618 if uncompressed_file_size__.is_some() {
8619 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
8620 }
8621 uncompressed_file_size__ =
8622 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8623 ;
8624 }
8625 GeneratedField::VnodePartitionCount => {
8626 if vnode_partition_count__.is_some() {
8627 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
8628 }
8629 vnode_partition_count__ =
8630 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8631 ;
8632 }
8633 }
8634 }
8635 Ok(Level {
8636 level_idx: level_idx__.unwrap_or_default(),
8637 level_type: level_type__.unwrap_or_default(),
8638 table_infos: table_infos__.unwrap_or_default(),
8639 total_file_size: total_file_size__.unwrap_or_default(),
8640 sub_level_id: sub_level_id__.unwrap_or_default(),
8641 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
8642 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
8643 })
8644 }
8645 }
8646 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
8647 }
8648}
8649impl serde::Serialize for LevelHandler {
8650 #[allow(deprecated)]
8651 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8652 where
8653 S: serde::Serializer,
8654 {
8655 use serde::ser::SerializeStruct;
8656 let mut len = 0;
8657 if self.level != 0 {
8658 len += 1;
8659 }
8660 if !self.tasks.is_empty() {
8661 len += 1;
8662 }
8663 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
8664 if self.level != 0 {
8665 struct_ser.serialize_field("level", &self.level)?;
8666 }
8667 if !self.tasks.is_empty() {
8668 struct_ser.serialize_field("tasks", &self.tasks)?;
8669 }
8670 struct_ser.end()
8671 }
8672}
8673impl<'de> serde::Deserialize<'de> for LevelHandler {
8674 #[allow(deprecated)]
8675 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8676 where
8677 D: serde::Deserializer<'de>,
8678 {
8679 const FIELDS: &[&str] = &[
8680 "level",
8681 "tasks",
8682 ];
8683
8684 #[allow(clippy::enum_variant_names)]
8685 enum GeneratedField {
8686 Level,
8687 Tasks,
8688 }
8689 impl<'de> serde::Deserialize<'de> for GeneratedField {
8690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8691 where
8692 D: serde::Deserializer<'de>,
8693 {
8694 struct GeneratedVisitor;
8695
8696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8697 type Value = GeneratedField;
8698
8699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8700 write!(formatter, "expected one of: {:?}", &FIELDS)
8701 }
8702
8703 #[allow(unused_variables)]
8704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8705 where
8706 E: serde::de::Error,
8707 {
8708 match value {
8709 "level" => Ok(GeneratedField::Level),
8710 "tasks" => Ok(GeneratedField::Tasks),
8711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8712 }
8713 }
8714 }
8715 deserializer.deserialize_identifier(GeneratedVisitor)
8716 }
8717 }
8718 struct GeneratedVisitor;
8719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8720 type Value = LevelHandler;
8721
8722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8723 formatter.write_str("struct hummock.LevelHandler")
8724 }
8725
8726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
8727 where
8728 V: serde::de::MapAccess<'de>,
8729 {
8730 let mut level__ = None;
8731 let mut tasks__ = None;
8732 while let Some(k) = map_.next_key()? {
8733 match k {
8734 GeneratedField::Level => {
8735 if level__.is_some() {
8736 return Err(serde::de::Error::duplicate_field("level"));
8737 }
8738 level__ =
8739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8740 ;
8741 }
8742 GeneratedField::Tasks => {
8743 if tasks__.is_some() {
8744 return Err(serde::de::Error::duplicate_field("tasks"));
8745 }
8746 tasks__ = Some(map_.next_value()?);
8747 }
8748 }
8749 }
8750 Ok(LevelHandler {
8751 level: level__.unwrap_or_default(),
8752 tasks: tasks__.unwrap_or_default(),
8753 })
8754 }
8755 }
8756 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
8757 }
8758}
8759impl serde::Serialize for level_handler::RunningCompactTask {
8760 #[allow(deprecated)]
8761 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8762 where
8763 S: serde::Serializer,
8764 {
8765 use serde::ser::SerializeStruct;
8766 let mut len = 0;
8767 if self.task_id != 0 {
8768 len += 1;
8769 }
8770 if !self.ssts.is_empty() {
8771 len += 1;
8772 }
8773 if self.total_file_size != 0 {
8774 len += 1;
8775 }
8776 if self.target_level != 0 {
8777 len += 1;
8778 }
8779 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
8780 if self.task_id != 0 {
8781 #[allow(clippy::needless_borrow)]
8782 #[allow(clippy::needless_borrows_for_generic_args)]
8783 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
8784 }
8785 if !self.ssts.is_empty() {
8786 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8787 }
8788 if self.total_file_size != 0 {
8789 #[allow(clippy::needless_borrow)]
8790 #[allow(clippy::needless_borrows_for_generic_args)]
8791 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8792 }
8793 if self.target_level != 0 {
8794 struct_ser.serialize_field("targetLevel", &self.target_level)?;
8795 }
8796 struct_ser.end()
8797 }
8798}
8799impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
8800 #[allow(deprecated)]
8801 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8802 where
8803 D: serde::Deserializer<'de>,
8804 {
8805 const FIELDS: &[&str] = &[
8806 "task_id",
8807 "taskId",
8808 "ssts",
8809 "total_file_size",
8810 "totalFileSize",
8811 "target_level",
8812 "targetLevel",
8813 ];
8814
8815 #[allow(clippy::enum_variant_names)]
8816 enum GeneratedField {
8817 TaskId,
8818 Ssts,
8819 TotalFileSize,
8820 TargetLevel,
8821 }
8822 impl<'de> serde::Deserialize<'de> for GeneratedField {
8823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8824 where
8825 D: serde::Deserializer<'de>,
8826 {
8827 struct GeneratedVisitor;
8828
8829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8830 type Value = GeneratedField;
8831
8832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8833 write!(formatter, "expected one of: {:?}", &FIELDS)
8834 }
8835
8836 #[allow(unused_variables)]
8837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8838 where
8839 E: serde::de::Error,
8840 {
8841 match value {
8842 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8843 "ssts" => Ok(GeneratedField::Ssts),
8844 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8845 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
8846 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8847 }
8848 }
8849 }
8850 deserializer.deserialize_identifier(GeneratedVisitor)
8851 }
8852 }
8853 struct GeneratedVisitor;
8854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8855 type Value = level_handler::RunningCompactTask;
8856
8857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8858 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
8859 }
8860
8861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
8862 where
8863 V: serde::de::MapAccess<'de>,
8864 {
8865 let mut task_id__ = None;
8866 let mut ssts__ = None;
8867 let mut total_file_size__ = None;
8868 let mut target_level__ = None;
8869 while let Some(k) = map_.next_key()? {
8870 match k {
8871 GeneratedField::TaskId => {
8872 if task_id__.is_some() {
8873 return Err(serde::de::Error::duplicate_field("taskId"));
8874 }
8875 task_id__ =
8876 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8877 ;
8878 }
8879 GeneratedField::Ssts => {
8880 if ssts__.is_some() {
8881 return Err(serde::de::Error::duplicate_field("ssts"));
8882 }
8883 ssts__ =
8884 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8885 .into_iter().map(|x| x.0).collect())
8886 ;
8887 }
8888 GeneratedField::TotalFileSize => {
8889 if total_file_size__.is_some() {
8890 return Err(serde::de::Error::duplicate_field("totalFileSize"));
8891 }
8892 total_file_size__ =
8893 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8894 ;
8895 }
8896 GeneratedField::TargetLevel => {
8897 if target_level__.is_some() {
8898 return Err(serde::de::Error::duplicate_field("targetLevel"));
8899 }
8900 target_level__ =
8901 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8902 ;
8903 }
8904 }
8905 }
8906 Ok(level_handler::RunningCompactTask {
8907 task_id: task_id__.unwrap_or_default(),
8908 ssts: ssts__.unwrap_or_default(),
8909 total_file_size: total_file_size__.unwrap_or_default(),
8910 target_level: target_level__.unwrap_or_default(),
8911 })
8912 }
8913 }
8914 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
8915 }
8916}
8917impl serde::Serialize for LevelType {
8918 #[allow(deprecated)]
8919 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8920 where
8921 S: serde::Serializer,
8922 {
8923 let variant = match self {
8924 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
8925 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
8926 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
8927 };
8928 serializer.serialize_str(variant)
8929 }
8930}
8931impl<'de> serde::Deserialize<'de> for LevelType {
8932 #[allow(deprecated)]
8933 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8934 where
8935 D: serde::Deserializer<'de>,
8936 {
8937 const FIELDS: &[&str] = &[
8938 "LEVEL_TYPE_UNSPECIFIED",
8939 "LEVEL_TYPE_NONOVERLAPPING",
8940 "LEVEL_TYPE_OVERLAPPING",
8941 ];
8942
8943 struct GeneratedVisitor;
8944
8945 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8946 type Value = LevelType;
8947
8948 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8949 write!(formatter, "expected one of: {:?}", &FIELDS)
8950 }
8951
8952 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8953 where
8954 E: serde::de::Error,
8955 {
8956 i32::try_from(v)
8957 .ok()
8958 .and_then(|x| x.try_into().ok())
8959 .ok_or_else(|| {
8960 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8961 })
8962 }
8963
8964 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8965 where
8966 E: serde::de::Error,
8967 {
8968 i32::try_from(v)
8969 .ok()
8970 .and_then(|x| x.try_into().ok())
8971 .ok_or_else(|| {
8972 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8973 })
8974 }
8975
8976 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8977 where
8978 E: serde::de::Error,
8979 {
8980 match value {
8981 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
8982 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
8983 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
8984 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8985 }
8986 }
8987 }
8988 deserializer.deserialize_any(GeneratedVisitor)
8989 }
8990}
8991impl serde::Serialize for ListActiveWriteLimitRequest {
8992 #[allow(deprecated)]
8993 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8994 where
8995 S: serde::Serializer,
8996 {
8997 use serde::ser::SerializeStruct;
8998 let len = 0;
8999 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
9000 struct_ser.end()
9001 }
9002}
9003impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
9004 #[allow(deprecated)]
9005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9006 where
9007 D: serde::Deserializer<'de>,
9008 {
9009 const FIELDS: &[&str] = &[
9010 ];
9011
9012 #[allow(clippy::enum_variant_names)]
9013 enum GeneratedField {
9014 }
9015 impl<'de> serde::Deserialize<'de> for GeneratedField {
9016 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9017 where
9018 D: serde::Deserializer<'de>,
9019 {
9020 struct GeneratedVisitor;
9021
9022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9023 type Value = GeneratedField;
9024
9025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9026 write!(formatter, "expected one of: {:?}", &FIELDS)
9027 }
9028
9029 #[allow(unused_variables)]
9030 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9031 where
9032 E: serde::de::Error,
9033 {
9034 Err(serde::de::Error::unknown_field(value, FIELDS))
9035 }
9036 }
9037 deserializer.deserialize_identifier(GeneratedVisitor)
9038 }
9039 }
9040 struct GeneratedVisitor;
9041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9042 type Value = ListActiveWriteLimitRequest;
9043
9044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9045 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
9046 }
9047
9048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
9049 where
9050 V: serde::de::MapAccess<'de>,
9051 {
9052 while map_.next_key::<GeneratedField>()?.is_some() {
9053 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9054 }
9055 Ok(ListActiveWriteLimitRequest {
9056 })
9057 }
9058 }
9059 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
9060 }
9061}
9062impl serde::Serialize for ListActiveWriteLimitResponse {
9063 #[allow(deprecated)]
9064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9065 where
9066 S: serde::Serializer,
9067 {
9068 use serde::ser::SerializeStruct;
9069 let mut len = 0;
9070 if !self.write_limits.is_empty() {
9071 len += 1;
9072 }
9073 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
9074 if !self.write_limits.is_empty() {
9075 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
9076 }
9077 struct_ser.end()
9078 }
9079}
9080impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
9081 #[allow(deprecated)]
9082 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9083 where
9084 D: serde::Deserializer<'de>,
9085 {
9086 const FIELDS: &[&str] = &[
9087 "write_limits",
9088 "writeLimits",
9089 ];
9090
9091 #[allow(clippy::enum_variant_names)]
9092 enum GeneratedField {
9093 WriteLimits,
9094 }
9095 impl<'de> serde::Deserialize<'de> for GeneratedField {
9096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9097 where
9098 D: serde::Deserializer<'de>,
9099 {
9100 struct GeneratedVisitor;
9101
9102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9103 type Value = GeneratedField;
9104
9105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9106 write!(formatter, "expected one of: {:?}", &FIELDS)
9107 }
9108
9109 #[allow(unused_variables)]
9110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9111 where
9112 E: serde::de::Error,
9113 {
9114 match value {
9115 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
9116 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9117 }
9118 }
9119 }
9120 deserializer.deserialize_identifier(GeneratedVisitor)
9121 }
9122 }
9123 struct GeneratedVisitor;
9124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9125 type Value = ListActiveWriteLimitResponse;
9126
9127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9128 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
9129 }
9130
9131 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
9132 where
9133 V: serde::de::MapAccess<'de>,
9134 {
9135 let mut write_limits__ = None;
9136 while let Some(k) = map_.next_key()? {
9137 match k {
9138 GeneratedField::WriteLimits => {
9139 if write_limits__.is_some() {
9140 return Err(serde::de::Error::duplicate_field("writeLimits"));
9141 }
9142 write_limits__ = Some(
9143 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
9144 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9145 );
9146 }
9147 }
9148 }
9149 Ok(ListActiveWriteLimitResponse {
9150 write_limits: write_limits__.unwrap_or_default(),
9151 })
9152 }
9153 }
9154 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
9155 }
9156}
9157impl serde::Serialize for ListBranchedObjectRequest {
9158 #[allow(deprecated)]
9159 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9160 where
9161 S: serde::Serializer,
9162 {
9163 use serde::ser::SerializeStruct;
9164 let len = 0;
9165 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
9166 struct_ser.end()
9167 }
9168}
9169impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
9170 #[allow(deprecated)]
9171 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9172 where
9173 D: serde::Deserializer<'de>,
9174 {
9175 const FIELDS: &[&str] = &[
9176 ];
9177
9178 #[allow(clippy::enum_variant_names)]
9179 enum GeneratedField {
9180 }
9181 impl<'de> serde::Deserialize<'de> for GeneratedField {
9182 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9183 where
9184 D: serde::Deserializer<'de>,
9185 {
9186 struct GeneratedVisitor;
9187
9188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9189 type Value = GeneratedField;
9190
9191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9192 write!(formatter, "expected one of: {:?}", &FIELDS)
9193 }
9194
9195 #[allow(unused_variables)]
9196 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9197 where
9198 E: serde::de::Error,
9199 {
9200 Err(serde::de::Error::unknown_field(value, FIELDS))
9201 }
9202 }
9203 deserializer.deserialize_identifier(GeneratedVisitor)
9204 }
9205 }
9206 struct GeneratedVisitor;
9207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9208 type Value = ListBranchedObjectRequest;
9209
9210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9211 formatter.write_str("struct hummock.ListBranchedObjectRequest")
9212 }
9213
9214 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
9215 where
9216 V: serde::de::MapAccess<'de>,
9217 {
9218 while map_.next_key::<GeneratedField>()?.is_some() {
9219 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9220 }
9221 Ok(ListBranchedObjectRequest {
9222 })
9223 }
9224 }
9225 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
9226 }
9227}
9228impl serde::Serialize for ListBranchedObjectResponse {
9229 #[allow(deprecated)]
9230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9231 where
9232 S: serde::Serializer,
9233 {
9234 use serde::ser::SerializeStruct;
9235 let mut len = 0;
9236 if !self.branched_objects.is_empty() {
9237 len += 1;
9238 }
9239 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
9240 if !self.branched_objects.is_empty() {
9241 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
9242 }
9243 struct_ser.end()
9244 }
9245}
9246impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
9247 #[allow(deprecated)]
9248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9249 where
9250 D: serde::Deserializer<'de>,
9251 {
9252 const FIELDS: &[&str] = &[
9253 "branched_objects",
9254 "branchedObjects",
9255 ];
9256
9257 #[allow(clippy::enum_variant_names)]
9258 enum GeneratedField {
9259 BranchedObjects,
9260 }
9261 impl<'de> serde::Deserialize<'de> for GeneratedField {
9262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9263 where
9264 D: serde::Deserializer<'de>,
9265 {
9266 struct GeneratedVisitor;
9267
9268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9269 type Value = GeneratedField;
9270
9271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9272 write!(formatter, "expected one of: {:?}", &FIELDS)
9273 }
9274
9275 #[allow(unused_variables)]
9276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9277 where
9278 E: serde::de::Error,
9279 {
9280 match value {
9281 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
9282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9283 }
9284 }
9285 }
9286 deserializer.deserialize_identifier(GeneratedVisitor)
9287 }
9288 }
9289 struct GeneratedVisitor;
9290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9291 type Value = ListBranchedObjectResponse;
9292
9293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9294 formatter.write_str("struct hummock.ListBranchedObjectResponse")
9295 }
9296
9297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
9298 where
9299 V: serde::de::MapAccess<'de>,
9300 {
9301 let mut branched_objects__ = None;
9302 while let Some(k) = map_.next_key()? {
9303 match k {
9304 GeneratedField::BranchedObjects => {
9305 if branched_objects__.is_some() {
9306 return Err(serde::de::Error::duplicate_field("branchedObjects"));
9307 }
9308 branched_objects__ = Some(map_.next_value()?);
9309 }
9310 }
9311 }
9312 Ok(ListBranchedObjectResponse {
9313 branched_objects: branched_objects__.unwrap_or_default(),
9314 })
9315 }
9316 }
9317 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
9318 }
9319}
9320impl serde::Serialize for ListCompactTaskAssignmentRequest {
9321 #[allow(deprecated)]
9322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9323 where
9324 S: serde::Serializer,
9325 {
9326 use serde::ser::SerializeStruct;
9327 let len = 0;
9328 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
9329 struct_ser.end()
9330 }
9331}
9332impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
9333 #[allow(deprecated)]
9334 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9335 where
9336 D: serde::Deserializer<'de>,
9337 {
9338 const FIELDS: &[&str] = &[
9339 ];
9340
9341 #[allow(clippy::enum_variant_names)]
9342 enum GeneratedField {
9343 }
9344 impl<'de> serde::Deserialize<'de> for GeneratedField {
9345 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9346 where
9347 D: serde::Deserializer<'de>,
9348 {
9349 struct GeneratedVisitor;
9350
9351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9352 type Value = GeneratedField;
9353
9354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9355 write!(formatter, "expected one of: {:?}", &FIELDS)
9356 }
9357
9358 #[allow(unused_variables)]
9359 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9360 where
9361 E: serde::de::Error,
9362 {
9363 Err(serde::de::Error::unknown_field(value, FIELDS))
9364 }
9365 }
9366 deserializer.deserialize_identifier(GeneratedVisitor)
9367 }
9368 }
9369 struct GeneratedVisitor;
9370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9371 type Value = ListCompactTaskAssignmentRequest;
9372
9373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9374 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
9375 }
9376
9377 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
9378 where
9379 V: serde::de::MapAccess<'de>,
9380 {
9381 while map_.next_key::<GeneratedField>()?.is_some() {
9382 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9383 }
9384 Ok(ListCompactTaskAssignmentRequest {
9385 })
9386 }
9387 }
9388 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
9389 }
9390}
9391impl serde::Serialize for ListCompactTaskAssignmentResponse {
9392 #[allow(deprecated)]
9393 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9394 where
9395 S: serde::Serializer,
9396 {
9397 use serde::ser::SerializeStruct;
9398 let mut len = 0;
9399 if !self.task_assignment.is_empty() {
9400 len += 1;
9401 }
9402 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
9403 if !self.task_assignment.is_empty() {
9404 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
9405 }
9406 struct_ser.end()
9407 }
9408}
9409impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
9410 #[allow(deprecated)]
9411 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9412 where
9413 D: serde::Deserializer<'de>,
9414 {
9415 const FIELDS: &[&str] = &[
9416 "task_assignment",
9417 "taskAssignment",
9418 ];
9419
9420 #[allow(clippy::enum_variant_names)]
9421 enum GeneratedField {
9422 TaskAssignment,
9423 }
9424 impl<'de> serde::Deserialize<'de> for GeneratedField {
9425 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9426 where
9427 D: serde::Deserializer<'de>,
9428 {
9429 struct GeneratedVisitor;
9430
9431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9432 type Value = GeneratedField;
9433
9434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9435 write!(formatter, "expected one of: {:?}", &FIELDS)
9436 }
9437
9438 #[allow(unused_variables)]
9439 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9440 where
9441 E: serde::de::Error,
9442 {
9443 match value {
9444 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
9445 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9446 }
9447 }
9448 }
9449 deserializer.deserialize_identifier(GeneratedVisitor)
9450 }
9451 }
9452 struct GeneratedVisitor;
9453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9454 type Value = ListCompactTaskAssignmentResponse;
9455
9456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9457 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
9458 }
9459
9460 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
9461 where
9462 V: serde::de::MapAccess<'de>,
9463 {
9464 let mut task_assignment__ = None;
9465 while let Some(k) = map_.next_key()? {
9466 match k {
9467 GeneratedField::TaskAssignment => {
9468 if task_assignment__.is_some() {
9469 return Err(serde::de::Error::duplicate_field("taskAssignment"));
9470 }
9471 task_assignment__ = Some(map_.next_value()?);
9472 }
9473 }
9474 }
9475 Ok(ListCompactTaskAssignmentResponse {
9476 task_assignment: task_assignment__.unwrap_or_default(),
9477 })
9478 }
9479 }
9480 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
9481 }
9482}
9483impl serde::Serialize for ListCompactTaskProgressRequest {
9484 #[allow(deprecated)]
9485 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9486 where
9487 S: serde::Serializer,
9488 {
9489 use serde::ser::SerializeStruct;
9490 let len = 0;
9491 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
9492 struct_ser.end()
9493 }
9494}
9495impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
9496 #[allow(deprecated)]
9497 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9498 where
9499 D: serde::Deserializer<'de>,
9500 {
9501 const FIELDS: &[&str] = &[
9502 ];
9503
9504 #[allow(clippy::enum_variant_names)]
9505 enum GeneratedField {
9506 }
9507 impl<'de> serde::Deserialize<'de> for GeneratedField {
9508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9509 where
9510 D: serde::Deserializer<'de>,
9511 {
9512 struct GeneratedVisitor;
9513
9514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9515 type Value = GeneratedField;
9516
9517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9518 write!(formatter, "expected one of: {:?}", &FIELDS)
9519 }
9520
9521 #[allow(unused_variables)]
9522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9523 where
9524 E: serde::de::Error,
9525 {
9526 Err(serde::de::Error::unknown_field(value, FIELDS))
9527 }
9528 }
9529 deserializer.deserialize_identifier(GeneratedVisitor)
9530 }
9531 }
9532 struct GeneratedVisitor;
9533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9534 type Value = ListCompactTaskProgressRequest;
9535
9536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9537 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
9538 }
9539
9540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
9541 where
9542 V: serde::de::MapAccess<'de>,
9543 {
9544 while map_.next_key::<GeneratedField>()?.is_some() {
9545 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9546 }
9547 Ok(ListCompactTaskProgressRequest {
9548 })
9549 }
9550 }
9551 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
9552 }
9553}
9554impl serde::Serialize for ListCompactTaskProgressResponse {
9555 #[allow(deprecated)]
9556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9557 where
9558 S: serde::Serializer,
9559 {
9560 use serde::ser::SerializeStruct;
9561 let mut len = 0;
9562 if !self.task_progress.is_empty() {
9563 len += 1;
9564 }
9565 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
9566 if !self.task_progress.is_empty() {
9567 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
9568 }
9569 struct_ser.end()
9570 }
9571}
9572impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
9573 #[allow(deprecated)]
9574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9575 where
9576 D: serde::Deserializer<'de>,
9577 {
9578 const FIELDS: &[&str] = &[
9579 "task_progress",
9580 "taskProgress",
9581 ];
9582
9583 #[allow(clippy::enum_variant_names)]
9584 enum GeneratedField {
9585 TaskProgress,
9586 }
9587 impl<'de> serde::Deserialize<'de> for GeneratedField {
9588 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9589 where
9590 D: serde::Deserializer<'de>,
9591 {
9592 struct GeneratedVisitor;
9593
9594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9595 type Value = GeneratedField;
9596
9597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9598 write!(formatter, "expected one of: {:?}", &FIELDS)
9599 }
9600
9601 #[allow(unused_variables)]
9602 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9603 where
9604 E: serde::de::Error,
9605 {
9606 match value {
9607 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
9608 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9609 }
9610 }
9611 }
9612 deserializer.deserialize_identifier(GeneratedVisitor)
9613 }
9614 }
9615 struct GeneratedVisitor;
9616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9617 type Value = ListCompactTaskProgressResponse;
9618
9619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9620 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
9621 }
9622
9623 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
9624 where
9625 V: serde::de::MapAccess<'de>,
9626 {
9627 let mut task_progress__ = None;
9628 while let Some(k) = map_.next_key()? {
9629 match k {
9630 GeneratedField::TaskProgress => {
9631 if task_progress__.is_some() {
9632 return Err(serde::de::Error::duplicate_field("taskProgress"));
9633 }
9634 task_progress__ = Some(map_.next_value()?);
9635 }
9636 }
9637 }
9638 Ok(ListCompactTaskProgressResponse {
9639 task_progress: task_progress__.unwrap_or_default(),
9640 })
9641 }
9642 }
9643 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
9644 }
9645}
9646impl serde::Serialize for ListHummockMetaConfigRequest {
9647 #[allow(deprecated)]
9648 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9649 where
9650 S: serde::Serializer,
9651 {
9652 use serde::ser::SerializeStruct;
9653 let len = 0;
9654 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
9655 struct_ser.end()
9656 }
9657}
9658impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
9659 #[allow(deprecated)]
9660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9661 where
9662 D: serde::Deserializer<'de>,
9663 {
9664 const FIELDS: &[&str] = &[
9665 ];
9666
9667 #[allow(clippy::enum_variant_names)]
9668 enum GeneratedField {
9669 }
9670 impl<'de> serde::Deserialize<'de> for GeneratedField {
9671 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9672 where
9673 D: serde::Deserializer<'de>,
9674 {
9675 struct GeneratedVisitor;
9676
9677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9678 type Value = GeneratedField;
9679
9680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9681 write!(formatter, "expected one of: {:?}", &FIELDS)
9682 }
9683
9684 #[allow(unused_variables)]
9685 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9686 where
9687 E: serde::de::Error,
9688 {
9689 Err(serde::de::Error::unknown_field(value, FIELDS))
9690 }
9691 }
9692 deserializer.deserialize_identifier(GeneratedVisitor)
9693 }
9694 }
9695 struct GeneratedVisitor;
9696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9697 type Value = ListHummockMetaConfigRequest;
9698
9699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9700 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
9701 }
9702
9703 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
9704 where
9705 V: serde::de::MapAccess<'de>,
9706 {
9707 while map_.next_key::<GeneratedField>()?.is_some() {
9708 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9709 }
9710 Ok(ListHummockMetaConfigRequest {
9711 })
9712 }
9713 }
9714 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
9715 }
9716}
9717impl serde::Serialize for ListHummockMetaConfigResponse {
9718 #[allow(deprecated)]
9719 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9720 where
9721 S: serde::Serializer,
9722 {
9723 use serde::ser::SerializeStruct;
9724 let mut len = 0;
9725 if !self.configs.is_empty() {
9726 len += 1;
9727 }
9728 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
9729 if !self.configs.is_empty() {
9730 struct_ser.serialize_field("configs", &self.configs)?;
9731 }
9732 struct_ser.end()
9733 }
9734}
9735impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
9736 #[allow(deprecated)]
9737 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9738 where
9739 D: serde::Deserializer<'de>,
9740 {
9741 const FIELDS: &[&str] = &[
9742 "configs",
9743 ];
9744
9745 #[allow(clippy::enum_variant_names)]
9746 enum GeneratedField {
9747 Configs,
9748 }
9749 impl<'de> serde::Deserialize<'de> for GeneratedField {
9750 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9751 where
9752 D: serde::Deserializer<'de>,
9753 {
9754 struct GeneratedVisitor;
9755
9756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9757 type Value = GeneratedField;
9758
9759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9760 write!(formatter, "expected one of: {:?}", &FIELDS)
9761 }
9762
9763 #[allow(unused_variables)]
9764 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9765 where
9766 E: serde::de::Error,
9767 {
9768 match value {
9769 "configs" => Ok(GeneratedField::Configs),
9770 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9771 }
9772 }
9773 }
9774 deserializer.deserialize_identifier(GeneratedVisitor)
9775 }
9776 }
9777 struct GeneratedVisitor;
9778 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9779 type Value = ListHummockMetaConfigResponse;
9780
9781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9782 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
9783 }
9784
9785 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
9786 where
9787 V: serde::de::MapAccess<'de>,
9788 {
9789 let mut configs__ = None;
9790 while let Some(k) = map_.next_key()? {
9791 match k {
9792 GeneratedField::Configs => {
9793 if configs__.is_some() {
9794 return Err(serde::de::Error::duplicate_field("configs"));
9795 }
9796 configs__ = Some(
9797 map_.next_value::<std::collections::HashMap<_, _>>()?
9798 );
9799 }
9800 }
9801 }
9802 Ok(ListHummockMetaConfigResponse {
9803 configs: configs__.unwrap_or_default(),
9804 })
9805 }
9806 }
9807 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
9808 }
9809}
9810impl serde::Serialize for ListVersionDeltasRequest {
9811 #[allow(deprecated)]
9812 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9813 where
9814 S: serde::Serializer,
9815 {
9816 use serde::ser::SerializeStruct;
9817 let mut len = 0;
9818 if self.start_id != 0 {
9819 len += 1;
9820 }
9821 if self.num_limit != 0 {
9822 len += 1;
9823 }
9824 if self.committed_epoch_limit != 0 {
9825 len += 1;
9826 }
9827 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
9828 if self.start_id != 0 {
9829 #[allow(clippy::needless_borrow)]
9830 #[allow(clippy::needless_borrows_for_generic_args)]
9831 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
9832 }
9833 if self.num_limit != 0 {
9834 struct_ser.serialize_field("numLimit", &self.num_limit)?;
9835 }
9836 if self.committed_epoch_limit != 0 {
9837 #[allow(clippy::needless_borrow)]
9838 #[allow(clippy::needless_borrows_for_generic_args)]
9839 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
9840 }
9841 struct_ser.end()
9842 }
9843}
9844impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
9845 #[allow(deprecated)]
9846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9847 where
9848 D: serde::Deserializer<'de>,
9849 {
9850 const FIELDS: &[&str] = &[
9851 "start_id",
9852 "startId",
9853 "num_limit",
9854 "numLimit",
9855 "committed_epoch_limit",
9856 "committedEpochLimit",
9857 ];
9858
9859 #[allow(clippy::enum_variant_names)]
9860 enum GeneratedField {
9861 StartId,
9862 NumLimit,
9863 CommittedEpochLimit,
9864 }
9865 impl<'de> serde::Deserialize<'de> for GeneratedField {
9866 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9867 where
9868 D: serde::Deserializer<'de>,
9869 {
9870 struct GeneratedVisitor;
9871
9872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9873 type Value = GeneratedField;
9874
9875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9876 write!(formatter, "expected one of: {:?}", &FIELDS)
9877 }
9878
9879 #[allow(unused_variables)]
9880 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9881 where
9882 E: serde::de::Error,
9883 {
9884 match value {
9885 "startId" | "start_id" => Ok(GeneratedField::StartId),
9886 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
9887 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
9888 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9889 }
9890 }
9891 }
9892 deserializer.deserialize_identifier(GeneratedVisitor)
9893 }
9894 }
9895 struct GeneratedVisitor;
9896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9897 type Value = ListVersionDeltasRequest;
9898
9899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9900 formatter.write_str("struct hummock.ListVersionDeltasRequest")
9901 }
9902
9903 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
9904 where
9905 V: serde::de::MapAccess<'de>,
9906 {
9907 let mut start_id__ = None;
9908 let mut num_limit__ = None;
9909 let mut committed_epoch_limit__ = None;
9910 while let Some(k) = map_.next_key()? {
9911 match k {
9912 GeneratedField::StartId => {
9913 if start_id__.is_some() {
9914 return Err(serde::de::Error::duplicate_field("startId"));
9915 }
9916 start_id__ =
9917 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9918 ;
9919 }
9920 GeneratedField::NumLimit => {
9921 if num_limit__.is_some() {
9922 return Err(serde::de::Error::duplicate_field("numLimit"));
9923 }
9924 num_limit__ =
9925 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9926 ;
9927 }
9928 GeneratedField::CommittedEpochLimit => {
9929 if committed_epoch_limit__.is_some() {
9930 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
9931 }
9932 committed_epoch_limit__ =
9933 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9934 ;
9935 }
9936 }
9937 }
9938 Ok(ListVersionDeltasRequest {
9939 start_id: start_id__.unwrap_or_default(),
9940 num_limit: num_limit__.unwrap_or_default(),
9941 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
9942 })
9943 }
9944 }
9945 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
9946 }
9947}
9948impl serde::Serialize for ListVersionDeltasResponse {
9949 #[allow(deprecated)]
9950 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9951 where
9952 S: serde::Serializer,
9953 {
9954 use serde::ser::SerializeStruct;
9955 let mut len = 0;
9956 if self.version_deltas.is_some() {
9957 len += 1;
9958 }
9959 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
9960 if let Some(v) = self.version_deltas.as_ref() {
9961 struct_ser.serialize_field("versionDeltas", v)?;
9962 }
9963 struct_ser.end()
9964 }
9965}
9966impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
9967 #[allow(deprecated)]
9968 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9969 where
9970 D: serde::Deserializer<'de>,
9971 {
9972 const FIELDS: &[&str] = &[
9973 "version_deltas",
9974 "versionDeltas",
9975 ];
9976
9977 #[allow(clippy::enum_variant_names)]
9978 enum GeneratedField {
9979 VersionDeltas,
9980 }
9981 impl<'de> serde::Deserialize<'de> for GeneratedField {
9982 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9983 where
9984 D: serde::Deserializer<'de>,
9985 {
9986 struct GeneratedVisitor;
9987
9988 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9989 type Value = GeneratedField;
9990
9991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9992 write!(formatter, "expected one of: {:?}", &FIELDS)
9993 }
9994
9995 #[allow(unused_variables)]
9996 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9997 where
9998 E: serde::de::Error,
9999 {
10000 match value {
10001 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
10002 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10003 }
10004 }
10005 }
10006 deserializer.deserialize_identifier(GeneratedVisitor)
10007 }
10008 }
10009 struct GeneratedVisitor;
10010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10011 type Value = ListVersionDeltasResponse;
10012
10013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10014 formatter.write_str("struct hummock.ListVersionDeltasResponse")
10015 }
10016
10017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
10018 where
10019 V: serde::de::MapAccess<'de>,
10020 {
10021 let mut version_deltas__ = None;
10022 while let Some(k) = map_.next_key()? {
10023 match k {
10024 GeneratedField::VersionDeltas => {
10025 if version_deltas__.is_some() {
10026 return Err(serde::de::Error::duplicate_field("versionDeltas"));
10027 }
10028 version_deltas__ = map_.next_value()?;
10029 }
10030 }
10031 }
10032 Ok(ListVersionDeltasResponse {
10033 version_deltas: version_deltas__,
10034 })
10035 }
10036 }
10037 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
10038 }
10039}
10040impl serde::Serialize for MergeCompactionGroupRequest {
10041 #[allow(deprecated)]
10042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10043 where
10044 S: serde::Serializer,
10045 {
10046 use serde::ser::SerializeStruct;
10047 let mut len = 0;
10048 if self.left_group_id != 0 {
10049 len += 1;
10050 }
10051 if self.right_group_id != 0 {
10052 len += 1;
10053 }
10054 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
10055 if self.left_group_id != 0 {
10056 #[allow(clippy::needless_borrow)]
10057 #[allow(clippy::needless_borrows_for_generic_args)]
10058 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
10059 }
10060 if self.right_group_id != 0 {
10061 #[allow(clippy::needless_borrow)]
10062 #[allow(clippy::needless_borrows_for_generic_args)]
10063 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
10064 }
10065 struct_ser.end()
10066 }
10067}
10068impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
10069 #[allow(deprecated)]
10070 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10071 where
10072 D: serde::Deserializer<'de>,
10073 {
10074 const FIELDS: &[&str] = &[
10075 "left_group_id",
10076 "leftGroupId",
10077 "right_group_id",
10078 "rightGroupId",
10079 ];
10080
10081 #[allow(clippy::enum_variant_names)]
10082 enum GeneratedField {
10083 LeftGroupId,
10084 RightGroupId,
10085 }
10086 impl<'de> serde::Deserialize<'de> for GeneratedField {
10087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10088 where
10089 D: serde::Deserializer<'de>,
10090 {
10091 struct GeneratedVisitor;
10092
10093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10094 type Value = GeneratedField;
10095
10096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10097 write!(formatter, "expected one of: {:?}", &FIELDS)
10098 }
10099
10100 #[allow(unused_variables)]
10101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10102 where
10103 E: serde::de::Error,
10104 {
10105 match value {
10106 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
10107 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
10108 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10109 }
10110 }
10111 }
10112 deserializer.deserialize_identifier(GeneratedVisitor)
10113 }
10114 }
10115 struct GeneratedVisitor;
10116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10117 type Value = MergeCompactionGroupRequest;
10118
10119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10120 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
10121 }
10122
10123 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
10124 where
10125 V: serde::de::MapAccess<'de>,
10126 {
10127 let mut left_group_id__ = None;
10128 let mut right_group_id__ = None;
10129 while let Some(k) = map_.next_key()? {
10130 match k {
10131 GeneratedField::LeftGroupId => {
10132 if left_group_id__.is_some() {
10133 return Err(serde::de::Error::duplicate_field("leftGroupId"));
10134 }
10135 left_group_id__ =
10136 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10137 ;
10138 }
10139 GeneratedField::RightGroupId => {
10140 if right_group_id__.is_some() {
10141 return Err(serde::de::Error::duplicate_field("rightGroupId"));
10142 }
10143 right_group_id__ =
10144 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10145 ;
10146 }
10147 }
10148 }
10149 Ok(MergeCompactionGroupRequest {
10150 left_group_id: left_group_id__.unwrap_or_default(),
10151 right_group_id: right_group_id__.unwrap_or_default(),
10152 })
10153 }
10154 }
10155 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
10156 }
10157}
10158impl serde::Serialize for MergeCompactionGroupResponse {
10159 #[allow(deprecated)]
10160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10161 where
10162 S: serde::Serializer,
10163 {
10164 use serde::ser::SerializeStruct;
10165 let len = 0;
10166 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
10167 struct_ser.end()
10168 }
10169}
10170impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
10171 #[allow(deprecated)]
10172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10173 where
10174 D: serde::Deserializer<'de>,
10175 {
10176 const FIELDS: &[&str] = &[
10177 ];
10178
10179 #[allow(clippy::enum_variant_names)]
10180 enum GeneratedField {
10181 }
10182 impl<'de> serde::Deserialize<'de> for GeneratedField {
10183 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10184 where
10185 D: serde::Deserializer<'de>,
10186 {
10187 struct GeneratedVisitor;
10188
10189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10190 type Value = GeneratedField;
10191
10192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10193 write!(formatter, "expected one of: {:?}", &FIELDS)
10194 }
10195
10196 #[allow(unused_variables)]
10197 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10198 where
10199 E: serde::de::Error,
10200 {
10201 Err(serde::de::Error::unknown_field(value, FIELDS))
10202 }
10203 }
10204 deserializer.deserialize_identifier(GeneratedVisitor)
10205 }
10206 }
10207 struct GeneratedVisitor;
10208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10209 type Value = MergeCompactionGroupResponse;
10210
10211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10212 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
10213 }
10214
10215 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
10216 where
10217 V: serde::de::MapAccess<'de>,
10218 {
10219 while map_.next_key::<GeneratedField>()?.is_some() {
10220 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10221 }
10222 Ok(MergeCompactionGroupResponse {
10223 })
10224 }
10225 }
10226 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
10227 }
10228}
10229impl serde::Serialize for NewL0SubLevel {
10230 #[allow(deprecated)]
10231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10232 where
10233 S: serde::Serializer,
10234 {
10235 use serde::ser::SerializeStruct;
10236 let mut len = 0;
10237 if !self.inserted_table_infos.is_empty() {
10238 len += 1;
10239 }
10240 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
10241 if !self.inserted_table_infos.is_empty() {
10242 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
10243 }
10244 struct_ser.end()
10245 }
10246}
10247impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
10248 #[allow(deprecated)]
10249 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10250 where
10251 D: serde::Deserializer<'de>,
10252 {
10253 const FIELDS: &[&str] = &[
10254 "inserted_table_infos",
10255 "insertedTableInfos",
10256 ];
10257
10258 #[allow(clippy::enum_variant_names)]
10259 enum GeneratedField {
10260 InsertedTableInfos,
10261 }
10262 impl<'de> serde::Deserialize<'de> for GeneratedField {
10263 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10264 where
10265 D: serde::Deserializer<'de>,
10266 {
10267 struct GeneratedVisitor;
10268
10269 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10270 type Value = GeneratedField;
10271
10272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10273 write!(formatter, "expected one of: {:?}", &FIELDS)
10274 }
10275
10276 #[allow(unused_variables)]
10277 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10278 where
10279 E: serde::de::Error,
10280 {
10281 match value {
10282 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
10283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10284 }
10285 }
10286 }
10287 deserializer.deserialize_identifier(GeneratedVisitor)
10288 }
10289 }
10290 struct GeneratedVisitor;
10291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10292 type Value = NewL0SubLevel;
10293
10294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10295 formatter.write_str("struct hummock.NewL0SubLevel")
10296 }
10297
10298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
10299 where
10300 V: serde::de::MapAccess<'de>,
10301 {
10302 let mut inserted_table_infos__ = None;
10303 while let Some(k) = map_.next_key()? {
10304 match k {
10305 GeneratedField::InsertedTableInfos => {
10306 if inserted_table_infos__.is_some() {
10307 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
10308 }
10309 inserted_table_infos__ = Some(map_.next_value()?);
10310 }
10311 }
10312 }
10313 Ok(NewL0SubLevel {
10314 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
10315 })
10316 }
10317 }
10318 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
10319 }
10320}
10321impl serde::Serialize for OverlappingLevel {
10322 #[allow(deprecated)]
10323 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10324 where
10325 S: serde::Serializer,
10326 {
10327 use serde::ser::SerializeStruct;
10328 let mut len = 0;
10329 if !self.sub_levels.is_empty() {
10330 len += 1;
10331 }
10332 if self.total_file_size != 0 {
10333 len += 1;
10334 }
10335 if self.uncompressed_file_size != 0 {
10336 len += 1;
10337 }
10338 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
10339 if !self.sub_levels.is_empty() {
10340 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
10341 }
10342 if self.total_file_size != 0 {
10343 #[allow(clippy::needless_borrow)]
10344 #[allow(clippy::needless_borrows_for_generic_args)]
10345 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
10346 }
10347 if self.uncompressed_file_size != 0 {
10348 #[allow(clippy::needless_borrow)]
10349 #[allow(clippy::needless_borrows_for_generic_args)]
10350 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
10351 }
10352 struct_ser.end()
10353 }
10354}
10355impl<'de> serde::Deserialize<'de> for OverlappingLevel {
10356 #[allow(deprecated)]
10357 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10358 where
10359 D: serde::Deserializer<'de>,
10360 {
10361 const FIELDS: &[&str] = &[
10362 "sub_levels",
10363 "subLevels",
10364 "total_file_size",
10365 "totalFileSize",
10366 "uncompressed_file_size",
10367 "uncompressedFileSize",
10368 ];
10369
10370 #[allow(clippy::enum_variant_names)]
10371 enum GeneratedField {
10372 SubLevels,
10373 TotalFileSize,
10374 UncompressedFileSize,
10375 }
10376 impl<'de> serde::Deserialize<'de> for GeneratedField {
10377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10378 where
10379 D: serde::Deserializer<'de>,
10380 {
10381 struct GeneratedVisitor;
10382
10383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10384 type Value = GeneratedField;
10385
10386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10387 write!(formatter, "expected one of: {:?}", &FIELDS)
10388 }
10389
10390 #[allow(unused_variables)]
10391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10392 where
10393 E: serde::de::Error,
10394 {
10395 match value {
10396 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
10397 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
10398 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
10399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10400 }
10401 }
10402 }
10403 deserializer.deserialize_identifier(GeneratedVisitor)
10404 }
10405 }
10406 struct GeneratedVisitor;
10407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10408 type Value = OverlappingLevel;
10409
10410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10411 formatter.write_str("struct hummock.OverlappingLevel")
10412 }
10413
10414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
10415 where
10416 V: serde::de::MapAccess<'de>,
10417 {
10418 let mut sub_levels__ = None;
10419 let mut total_file_size__ = None;
10420 let mut uncompressed_file_size__ = None;
10421 while let Some(k) = map_.next_key()? {
10422 match k {
10423 GeneratedField::SubLevels => {
10424 if sub_levels__.is_some() {
10425 return Err(serde::de::Error::duplicate_field("subLevels"));
10426 }
10427 sub_levels__ = Some(map_.next_value()?);
10428 }
10429 GeneratedField::TotalFileSize => {
10430 if total_file_size__.is_some() {
10431 return Err(serde::de::Error::duplicate_field("totalFileSize"));
10432 }
10433 total_file_size__ =
10434 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10435 ;
10436 }
10437 GeneratedField::UncompressedFileSize => {
10438 if uncompressed_file_size__.is_some() {
10439 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
10440 }
10441 uncompressed_file_size__ =
10442 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10443 ;
10444 }
10445 }
10446 }
10447 Ok(OverlappingLevel {
10448 sub_levels: sub_levels__.unwrap_or_default(),
10449 total_file_size: total_file_size__.unwrap_or_default(),
10450 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
10451 })
10452 }
10453 }
10454 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
10455 }
10456}
10457impl serde::Serialize for PinVersionRequest {
10458 #[allow(deprecated)]
10459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10460 where
10461 S: serde::Serializer,
10462 {
10463 use serde::ser::SerializeStruct;
10464 let mut len = 0;
10465 if self.context_id != 0 {
10466 len += 1;
10467 }
10468 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
10469 if self.context_id != 0 {
10470 struct_ser.serialize_field("contextId", &self.context_id)?;
10471 }
10472 struct_ser.end()
10473 }
10474}
10475impl<'de> serde::Deserialize<'de> for PinVersionRequest {
10476 #[allow(deprecated)]
10477 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10478 where
10479 D: serde::Deserializer<'de>,
10480 {
10481 const FIELDS: &[&str] = &[
10482 "context_id",
10483 "contextId",
10484 ];
10485
10486 #[allow(clippy::enum_variant_names)]
10487 enum GeneratedField {
10488 ContextId,
10489 }
10490 impl<'de> serde::Deserialize<'de> for GeneratedField {
10491 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10492 where
10493 D: serde::Deserializer<'de>,
10494 {
10495 struct GeneratedVisitor;
10496
10497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10498 type Value = GeneratedField;
10499
10500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10501 write!(formatter, "expected one of: {:?}", &FIELDS)
10502 }
10503
10504 #[allow(unused_variables)]
10505 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10506 where
10507 E: serde::de::Error,
10508 {
10509 match value {
10510 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
10511 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10512 }
10513 }
10514 }
10515 deserializer.deserialize_identifier(GeneratedVisitor)
10516 }
10517 }
10518 struct GeneratedVisitor;
10519 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10520 type Value = PinVersionRequest;
10521
10522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10523 formatter.write_str("struct hummock.PinVersionRequest")
10524 }
10525
10526 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
10527 where
10528 V: serde::de::MapAccess<'de>,
10529 {
10530 let mut context_id__ = None;
10531 while let Some(k) = map_.next_key()? {
10532 match k {
10533 GeneratedField::ContextId => {
10534 if context_id__.is_some() {
10535 return Err(serde::de::Error::duplicate_field("contextId"));
10536 }
10537 context_id__ =
10538 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10539 ;
10540 }
10541 }
10542 }
10543 Ok(PinVersionRequest {
10544 context_id: context_id__.unwrap_or_default(),
10545 })
10546 }
10547 }
10548 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
10549 }
10550}
10551impl serde::Serialize for PinVersionResponse {
10552 #[allow(deprecated)]
10553 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10554 where
10555 S: serde::Serializer,
10556 {
10557 use serde::ser::SerializeStruct;
10558 let mut len = 0;
10559 if self.pinned_version.is_some() {
10560 len += 1;
10561 }
10562 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
10563 if let Some(v) = self.pinned_version.as_ref() {
10564 struct_ser.serialize_field("pinnedVersion", v)?;
10565 }
10566 struct_ser.end()
10567 }
10568}
10569impl<'de> serde::Deserialize<'de> for PinVersionResponse {
10570 #[allow(deprecated)]
10571 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10572 where
10573 D: serde::Deserializer<'de>,
10574 {
10575 const FIELDS: &[&str] = &[
10576 "pinned_version",
10577 "pinnedVersion",
10578 ];
10579
10580 #[allow(clippy::enum_variant_names)]
10581 enum GeneratedField {
10582 PinnedVersion,
10583 }
10584 impl<'de> serde::Deserialize<'de> for GeneratedField {
10585 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10586 where
10587 D: serde::Deserializer<'de>,
10588 {
10589 struct GeneratedVisitor;
10590
10591 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10592 type Value = GeneratedField;
10593
10594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10595 write!(formatter, "expected one of: {:?}", &FIELDS)
10596 }
10597
10598 #[allow(unused_variables)]
10599 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10600 where
10601 E: serde::de::Error,
10602 {
10603 match value {
10604 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
10605 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10606 }
10607 }
10608 }
10609 deserializer.deserialize_identifier(GeneratedVisitor)
10610 }
10611 }
10612 struct GeneratedVisitor;
10613 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10614 type Value = PinVersionResponse;
10615
10616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10617 formatter.write_str("struct hummock.PinVersionResponse")
10618 }
10619
10620 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
10621 where
10622 V: serde::de::MapAccess<'de>,
10623 {
10624 let mut pinned_version__ = None;
10625 while let Some(k) = map_.next_key()? {
10626 match k {
10627 GeneratedField::PinnedVersion => {
10628 if pinned_version__.is_some() {
10629 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
10630 }
10631 pinned_version__ = map_.next_value()?;
10632 }
10633 }
10634 }
10635 Ok(PinVersionResponse {
10636 pinned_version: pinned_version__,
10637 })
10638 }
10639 }
10640 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
10641 }
10642}
10643impl serde::Serialize for PinnedVersionsSummary {
10644 #[allow(deprecated)]
10645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10646 where
10647 S: serde::Serializer,
10648 {
10649 use serde::ser::SerializeStruct;
10650 let mut len = 0;
10651 if !self.pinned_versions.is_empty() {
10652 len += 1;
10653 }
10654 if !self.workers.is_empty() {
10655 len += 1;
10656 }
10657 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
10658 if !self.pinned_versions.is_empty() {
10659 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
10660 }
10661 if !self.workers.is_empty() {
10662 struct_ser.serialize_field("workers", &self.workers)?;
10663 }
10664 struct_ser.end()
10665 }
10666}
10667impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
10668 #[allow(deprecated)]
10669 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10670 where
10671 D: serde::Deserializer<'de>,
10672 {
10673 const FIELDS: &[&str] = &[
10674 "pinned_versions",
10675 "pinnedVersions",
10676 "workers",
10677 ];
10678
10679 #[allow(clippy::enum_variant_names)]
10680 enum GeneratedField {
10681 PinnedVersions,
10682 Workers,
10683 }
10684 impl<'de> serde::Deserialize<'de> for GeneratedField {
10685 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10686 where
10687 D: serde::Deserializer<'de>,
10688 {
10689 struct GeneratedVisitor;
10690
10691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10692 type Value = GeneratedField;
10693
10694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10695 write!(formatter, "expected one of: {:?}", &FIELDS)
10696 }
10697
10698 #[allow(unused_variables)]
10699 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10700 where
10701 E: serde::de::Error,
10702 {
10703 match value {
10704 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
10705 "workers" => Ok(GeneratedField::Workers),
10706 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10707 }
10708 }
10709 }
10710 deserializer.deserialize_identifier(GeneratedVisitor)
10711 }
10712 }
10713 struct GeneratedVisitor;
10714 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10715 type Value = PinnedVersionsSummary;
10716
10717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10718 formatter.write_str("struct hummock.PinnedVersionsSummary")
10719 }
10720
10721 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
10722 where
10723 V: serde::de::MapAccess<'de>,
10724 {
10725 let mut pinned_versions__ = None;
10726 let mut workers__ = None;
10727 while let Some(k) = map_.next_key()? {
10728 match k {
10729 GeneratedField::PinnedVersions => {
10730 if pinned_versions__.is_some() {
10731 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
10732 }
10733 pinned_versions__ = Some(map_.next_value()?);
10734 }
10735 GeneratedField::Workers => {
10736 if workers__.is_some() {
10737 return Err(serde::de::Error::duplicate_field("workers"));
10738 }
10739 workers__ = Some(
10740 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10741 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10742 );
10743 }
10744 }
10745 }
10746 Ok(PinnedVersionsSummary {
10747 pinned_versions: pinned_versions__.unwrap_or_default(),
10748 workers: workers__.unwrap_or_default(),
10749 })
10750 }
10751 }
10752 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
10753 }
10754}
10755impl serde::Serialize for ReplayVersionDeltaRequest {
10756 #[allow(deprecated)]
10757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10758 where
10759 S: serde::Serializer,
10760 {
10761 use serde::ser::SerializeStruct;
10762 let mut len = 0;
10763 if self.version_delta.is_some() {
10764 len += 1;
10765 }
10766 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
10767 if let Some(v) = self.version_delta.as_ref() {
10768 struct_ser.serialize_field("versionDelta", v)?;
10769 }
10770 struct_ser.end()
10771 }
10772}
10773impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
10774 #[allow(deprecated)]
10775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10776 where
10777 D: serde::Deserializer<'de>,
10778 {
10779 const FIELDS: &[&str] = &[
10780 "version_delta",
10781 "versionDelta",
10782 ];
10783
10784 #[allow(clippy::enum_variant_names)]
10785 enum GeneratedField {
10786 VersionDelta,
10787 }
10788 impl<'de> serde::Deserialize<'de> for GeneratedField {
10789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10790 where
10791 D: serde::Deserializer<'de>,
10792 {
10793 struct GeneratedVisitor;
10794
10795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10796 type Value = GeneratedField;
10797
10798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10799 write!(formatter, "expected one of: {:?}", &FIELDS)
10800 }
10801
10802 #[allow(unused_variables)]
10803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10804 where
10805 E: serde::de::Error,
10806 {
10807 match value {
10808 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
10809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10810 }
10811 }
10812 }
10813 deserializer.deserialize_identifier(GeneratedVisitor)
10814 }
10815 }
10816 struct GeneratedVisitor;
10817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10818 type Value = ReplayVersionDeltaRequest;
10819
10820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10821 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
10822 }
10823
10824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
10825 where
10826 V: serde::de::MapAccess<'de>,
10827 {
10828 let mut version_delta__ = None;
10829 while let Some(k) = map_.next_key()? {
10830 match k {
10831 GeneratedField::VersionDelta => {
10832 if version_delta__.is_some() {
10833 return Err(serde::de::Error::duplicate_field("versionDelta"));
10834 }
10835 version_delta__ = map_.next_value()?;
10836 }
10837 }
10838 }
10839 Ok(ReplayVersionDeltaRequest {
10840 version_delta: version_delta__,
10841 })
10842 }
10843 }
10844 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
10845 }
10846}
10847impl serde::Serialize for ReplayVersionDeltaResponse {
10848 #[allow(deprecated)]
10849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10850 where
10851 S: serde::Serializer,
10852 {
10853 use serde::ser::SerializeStruct;
10854 let mut len = 0;
10855 if self.version.is_some() {
10856 len += 1;
10857 }
10858 if !self.modified_compaction_groups.is_empty() {
10859 len += 1;
10860 }
10861 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
10862 if let Some(v) = self.version.as_ref() {
10863 struct_ser.serialize_field("version", v)?;
10864 }
10865 if !self.modified_compaction_groups.is_empty() {
10866 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
10867 }
10868 struct_ser.end()
10869 }
10870}
10871impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
10872 #[allow(deprecated)]
10873 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10874 where
10875 D: serde::Deserializer<'de>,
10876 {
10877 const FIELDS: &[&str] = &[
10878 "version",
10879 "modified_compaction_groups",
10880 "modifiedCompactionGroups",
10881 ];
10882
10883 #[allow(clippy::enum_variant_names)]
10884 enum GeneratedField {
10885 Version,
10886 ModifiedCompactionGroups,
10887 }
10888 impl<'de> serde::Deserialize<'de> for GeneratedField {
10889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10890 where
10891 D: serde::Deserializer<'de>,
10892 {
10893 struct GeneratedVisitor;
10894
10895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10896 type Value = GeneratedField;
10897
10898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10899 write!(formatter, "expected one of: {:?}", &FIELDS)
10900 }
10901
10902 #[allow(unused_variables)]
10903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10904 where
10905 E: serde::de::Error,
10906 {
10907 match value {
10908 "version" => Ok(GeneratedField::Version),
10909 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
10910 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10911 }
10912 }
10913 }
10914 deserializer.deserialize_identifier(GeneratedVisitor)
10915 }
10916 }
10917 struct GeneratedVisitor;
10918 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10919 type Value = ReplayVersionDeltaResponse;
10920
10921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10922 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
10923 }
10924
10925 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
10926 where
10927 V: serde::de::MapAccess<'de>,
10928 {
10929 let mut version__ = None;
10930 let mut modified_compaction_groups__ = None;
10931 while let Some(k) = map_.next_key()? {
10932 match k {
10933 GeneratedField::Version => {
10934 if version__.is_some() {
10935 return Err(serde::de::Error::duplicate_field("version"));
10936 }
10937 version__ = map_.next_value()?;
10938 }
10939 GeneratedField::ModifiedCompactionGroups => {
10940 if modified_compaction_groups__.is_some() {
10941 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
10942 }
10943 modified_compaction_groups__ =
10944 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10945 .into_iter().map(|x| x.0).collect())
10946 ;
10947 }
10948 }
10949 }
10950 Ok(ReplayVersionDeltaResponse {
10951 version: version__,
10952 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
10953 })
10954 }
10955 }
10956 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
10957 }
10958}
10959impl serde::Serialize for ReportCompactionTaskRequest {
10960 #[allow(deprecated)]
10961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10962 where
10963 S: serde::Serializer,
10964 {
10965 use serde::ser::SerializeStruct;
10966 let mut len = 0;
10967 if self.event.is_some() {
10968 len += 1;
10969 }
10970 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
10971 if let Some(v) = self.event.as_ref() {
10972 match v {
10973 report_compaction_task_request::Event::ReportTask(v) => {
10974 struct_ser.serialize_field("reportTask", v)?;
10975 }
10976 report_compaction_task_request::Event::HeartBeat(v) => {
10977 struct_ser.serialize_field("heartBeat", v)?;
10978 }
10979 }
10980 }
10981 struct_ser.end()
10982 }
10983}
10984impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
10985 #[allow(deprecated)]
10986 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10987 where
10988 D: serde::Deserializer<'de>,
10989 {
10990 const FIELDS: &[&str] = &[
10991 "report_task",
10992 "reportTask",
10993 "heart_beat",
10994 "heartBeat",
10995 ];
10996
10997 #[allow(clippy::enum_variant_names)]
10998 enum GeneratedField {
10999 ReportTask,
11000 HeartBeat,
11001 }
11002 impl<'de> serde::Deserialize<'de> for GeneratedField {
11003 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11004 where
11005 D: serde::Deserializer<'de>,
11006 {
11007 struct GeneratedVisitor;
11008
11009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11010 type Value = GeneratedField;
11011
11012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11013 write!(formatter, "expected one of: {:?}", &FIELDS)
11014 }
11015
11016 #[allow(unused_variables)]
11017 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11018 where
11019 E: serde::de::Error,
11020 {
11021 match value {
11022 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
11023 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
11024 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11025 }
11026 }
11027 }
11028 deserializer.deserialize_identifier(GeneratedVisitor)
11029 }
11030 }
11031 struct GeneratedVisitor;
11032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11033 type Value = ReportCompactionTaskRequest;
11034
11035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11036 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
11037 }
11038
11039 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
11040 where
11041 V: serde::de::MapAccess<'de>,
11042 {
11043 let mut event__ = None;
11044 while let Some(k) = map_.next_key()? {
11045 match k {
11046 GeneratedField::ReportTask => {
11047 if event__.is_some() {
11048 return Err(serde::de::Error::duplicate_field("reportTask"));
11049 }
11050 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
11051;
11052 }
11053 GeneratedField::HeartBeat => {
11054 if event__.is_some() {
11055 return Err(serde::de::Error::duplicate_field("heartBeat"));
11056 }
11057 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
11058;
11059 }
11060 }
11061 }
11062 Ok(ReportCompactionTaskRequest {
11063 event: event__,
11064 })
11065 }
11066 }
11067 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
11068 }
11069}
11070impl serde::Serialize for report_compaction_task_request::HeartBeat {
11071 #[allow(deprecated)]
11072 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11073 where
11074 S: serde::Serializer,
11075 {
11076 use serde::ser::SerializeStruct;
11077 let mut len = 0;
11078 if !self.progress.is_empty() {
11079 len += 1;
11080 }
11081 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
11082 if !self.progress.is_empty() {
11083 struct_ser.serialize_field("progress", &self.progress)?;
11084 }
11085 struct_ser.end()
11086 }
11087}
11088impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
11089 #[allow(deprecated)]
11090 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11091 where
11092 D: serde::Deserializer<'de>,
11093 {
11094 const FIELDS: &[&str] = &[
11095 "progress",
11096 ];
11097
11098 #[allow(clippy::enum_variant_names)]
11099 enum GeneratedField {
11100 Progress,
11101 }
11102 impl<'de> serde::Deserialize<'de> for GeneratedField {
11103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11104 where
11105 D: serde::Deserializer<'de>,
11106 {
11107 struct GeneratedVisitor;
11108
11109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11110 type Value = GeneratedField;
11111
11112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11113 write!(formatter, "expected one of: {:?}", &FIELDS)
11114 }
11115
11116 #[allow(unused_variables)]
11117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11118 where
11119 E: serde::de::Error,
11120 {
11121 match value {
11122 "progress" => Ok(GeneratedField::Progress),
11123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11124 }
11125 }
11126 }
11127 deserializer.deserialize_identifier(GeneratedVisitor)
11128 }
11129 }
11130 struct GeneratedVisitor;
11131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11132 type Value = report_compaction_task_request::HeartBeat;
11133
11134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11135 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
11136 }
11137
11138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
11139 where
11140 V: serde::de::MapAccess<'de>,
11141 {
11142 let mut progress__ = None;
11143 while let Some(k) = map_.next_key()? {
11144 match k {
11145 GeneratedField::Progress => {
11146 if progress__.is_some() {
11147 return Err(serde::de::Error::duplicate_field("progress"));
11148 }
11149 progress__ = Some(map_.next_value()?);
11150 }
11151 }
11152 }
11153 Ok(report_compaction_task_request::HeartBeat {
11154 progress: progress__.unwrap_or_default(),
11155 })
11156 }
11157 }
11158 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
11159 }
11160}
11161impl serde::Serialize for report_compaction_task_request::ReportTask {
11162 #[allow(deprecated)]
11163 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11164 where
11165 S: serde::Serializer,
11166 {
11167 use serde::ser::SerializeStruct;
11168 let mut len = 0;
11169 if self.compact_task.is_some() {
11170 len += 1;
11171 }
11172 if !self.table_stats_change.is_empty() {
11173 len += 1;
11174 }
11175 if !self.object_timestamps.is_empty() {
11176 len += 1;
11177 }
11178 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
11179 if let Some(v) = self.compact_task.as_ref() {
11180 struct_ser.serialize_field("compactTask", v)?;
11181 }
11182 if !self.table_stats_change.is_empty() {
11183 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
11184 }
11185 if !self.object_timestamps.is_empty() {
11186 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
11187 .map(|(k, v)| (k, v.to_string())).collect();
11188 struct_ser.serialize_field("objectTimestamps", &v)?;
11189 }
11190 struct_ser.end()
11191 }
11192}
11193impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
11194 #[allow(deprecated)]
11195 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11196 where
11197 D: serde::Deserializer<'de>,
11198 {
11199 const FIELDS: &[&str] = &[
11200 "compact_task",
11201 "compactTask",
11202 "table_stats_change",
11203 "tableStatsChange",
11204 "object_timestamps",
11205 "objectTimestamps",
11206 ];
11207
11208 #[allow(clippy::enum_variant_names)]
11209 enum GeneratedField {
11210 CompactTask,
11211 TableStatsChange,
11212 ObjectTimestamps,
11213 }
11214 impl<'de> serde::Deserialize<'de> for GeneratedField {
11215 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11216 where
11217 D: serde::Deserializer<'de>,
11218 {
11219 struct GeneratedVisitor;
11220
11221 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11222 type Value = GeneratedField;
11223
11224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11225 write!(formatter, "expected one of: {:?}", &FIELDS)
11226 }
11227
11228 #[allow(unused_variables)]
11229 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11230 where
11231 E: serde::de::Error,
11232 {
11233 match value {
11234 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
11235 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
11236 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
11237 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11238 }
11239 }
11240 }
11241 deserializer.deserialize_identifier(GeneratedVisitor)
11242 }
11243 }
11244 struct GeneratedVisitor;
11245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11246 type Value = report_compaction_task_request::ReportTask;
11247
11248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11249 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
11250 }
11251
11252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
11253 where
11254 V: serde::de::MapAccess<'de>,
11255 {
11256 let mut compact_task__ = None;
11257 let mut table_stats_change__ = None;
11258 let mut object_timestamps__ = None;
11259 while let Some(k) = map_.next_key()? {
11260 match k {
11261 GeneratedField::CompactTask => {
11262 if compact_task__.is_some() {
11263 return Err(serde::de::Error::duplicate_field("compactTask"));
11264 }
11265 compact_task__ = map_.next_value()?;
11266 }
11267 GeneratedField::TableStatsChange => {
11268 if table_stats_change__.is_some() {
11269 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
11270 }
11271 table_stats_change__ = Some(
11272 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11273 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11274 );
11275 }
11276 GeneratedField::ObjectTimestamps => {
11277 if object_timestamps__.is_some() {
11278 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
11279 }
11280 object_timestamps__ = Some(
11281 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
11282 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
11283 );
11284 }
11285 }
11286 }
11287 Ok(report_compaction_task_request::ReportTask {
11288 compact_task: compact_task__,
11289 table_stats_change: table_stats_change__.unwrap_or_default(),
11290 object_timestamps: object_timestamps__.unwrap_or_default(),
11291 })
11292 }
11293 }
11294 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
11295 }
11296}
11297impl serde::Serialize for ReportCompactionTaskResponse {
11298 #[allow(deprecated)]
11299 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11300 where
11301 S: serde::Serializer,
11302 {
11303 use serde::ser::SerializeStruct;
11304 let mut len = 0;
11305 if self.status.is_some() {
11306 len += 1;
11307 }
11308 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
11309 if let Some(v) = self.status.as_ref() {
11310 struct_ser.serialize_field("status", v)?;
11311 }
11312 struct_ser.end()
11313 }
11314}
11315impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
11316 #[allow(deprecated)]
11317 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11318 where
11319 D: serde::Deserializer<'de>,
11320 {
11321 const FIELDS: &[&str] = &[
11322 "status",
11323 ];
11324
11325 #[allow(clippy::enum_variant_names)]
11326 enum GeneratedField {
11327 Status,
11328 }
11329 impl<'de> serde::Deserialize<'de> for GeneratedField {
11330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11331 where
11332 D: serde::Deserializer<'de>,
11333 {
11334 struct GeneratedVisitor;
11335
11336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11337 type Value = GeneratedField;
11338
11339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11340 write!(formatter, "expected one of: {:?}", &FIELDS)
11341 }
11342
11343 #[allow(unused_variables)]
11344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11345 where
11346 E: serde::de::Error,
11347 {
11348 match value {
11349 "status" => Ok(GeneratedField::Status),
11350 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11351 }
11352 }
11353 }
11354 deserializer.deserialize_identifier(GeneratedVisitor)
11355 }
11356 }
11357 struct GeneratedVisitor;
11358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11359 type Value = ReportCompactionTaskResponse;
11360
11361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11362 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
11363 }
11364
11365 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
11366 where
11367 V: serde::de::MapAccess<'de>,
11368 {
11369 let mut status__ = None;
11370 while let Some(k) = map_.next_key()? {
11371 match k {
11372 GeneratedField::Status => {
11373 if status__.is_some() {
11374 return Err(serde::de::Error::duplicate_field("status"));
11375 }
11376 status__ = map_.next_value()?;
11377 }
11378 }
11379 }
11380 Ok(ReportCompactionTaskResponse {
11381 status: status__,
11382 })
11383 }
11384 }
11385 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
11386 }
11387}
11388impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
11389 #[allow(deprecated)]
11390 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11391 where
11392 S: serde::Serializer,
11393 {
11394 use serde::ser::SerializeStruct;
11395 let len = 0;
11396 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
11397 struct_ser.end()
11398 }
11399}
11400impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
11401 #[allow(deprecated)]
11402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11403 where
11404 D: serde::Deserializer<'de>,
11405 {
11406 const FIELDS: &[&str] = &[
11407 ];
11408
11409 #[allow(clippy::enum_variant_names)]
11410 enum GeneratedField {
11411 }
11412 impl<'de> serde::Deserialize<'de> for GeneratedField {
11413 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11414 where
11415 D: serde::Deserializer<'de>,
11416 {
11417 struct GeneratedVisitor;
11418
11419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11420 type Value = GeneratedField;
11421
11422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11423 write!(formatter, "expected one of: {:?}", &FIELDS)
11424 }
11425
11426 #[allow(unused_variables)]
11427 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11428 where
11429 E: serde::de::Error,
11430 {
11431 Err(serde::de::Error::unknown_field(value, FIELDS))
11432 }
11433 }
11434 deserializer.deserialize_identifier(GeneratedVisitor)
11435 }
11436 }
11437 struct GeneratedVisitor;
11438 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11439 type Value = RiseCtlGetCheckpointVersionRequest;
11440
11441 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11442 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
11443 }
11444
11445 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
11446 where
11447 V: serde::de::MapAccess<'de>,
11448 {
11449 while map_.next_key::<GeneratedField>()?.is_some() {
11450 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11451 }
11452 Ok(RiseCtlGetCheckpointVersionRequest {
11453 })
11454 }
11455 }
11456 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
11457 }
11458}
11459impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
11460 #[allow(deprecated)]
11461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11462 where
11463 S: serde::Serializer,
11464 {
11465 use serde::ser::SerializeStruct;
11466 let mut len = 0;
11467 if self.checkpoint_version.is_some() {
11468 len += 1;
11469 }
11470 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
11471 if let Some(v) = self.checkpoint_version.as_ref() {
11472 struct_ser.serialize_field("checkpointVersion", v)?;
11473 }
11474 struct_ser.end()
11475 }
11476}
11477impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
11478 #[allow(deprecated)]
11479 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11480 where
11481 D: serde::Deserializer<'de>,
11482 {
11483 const FIELDS: &[&str] = &[
11484 "checkpoint_version",
11485 "checkpointVersion",
11486 ];
11487
11488 #[allow(clippy::enum_variant_names)]
11489 enum GeneratedField {
11490 CheckpointVersion,
11491 }
11492 impl<'de> serde::Deserialize<'de> for GeneratedField {
11493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11494 where
11495 D: serde::Deserializer<'de>,
11496 {
11497 struct GeneratedVisitor;
11498
11499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11500 type Value = GeneratedField;
11501
11502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11503 write!(formatter, "expected one of: {:?}", &FIELDS)
11504 }
11505
11506 #[allow(unused_variables)]
11507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11508 where
11509 E: serde::de::Error,
11510 {
11511 match value {
11512 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
11513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11514 }
11515 }
11516 }
11517 deserializer.deserialize_identifier(GeneratedVisitor)
11518 }
11519 }
11520 struct GeneratedVisitor;
11521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11522 type Value = RiseCtlGetCheckpointVersionResponse;
11523
11524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11525 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
11526 }
11527
11528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
11529 where
11530 V: serde::de::MapAccess<'de>,
11531 {
11532 let mut checkpoint_version__ = None;
11533 while let Some(k) = map_.next_key()? {
11534 match k {
11535 GeneratedField::CheckpointVersion => {
11536 if checkpoint_version__.is_some() {
11537 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
11538 }
11539 checkpoint_version__ = map_.next_value()?;
11540 }
11541 }
11542 }
11543 Ok(RiseCtlGetCheckpointVersionResponse {
11544 checkpoint_version: checkpoint_version__,
11545 })
11546 }
11547 }
11548 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
11549 }
11550}
11551impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
11552 #[allow(deprecated)]
11553 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11554 where
11555 S: serde::Serializer,
11556 {
11557 use serde::ser::SerializeStruct;
11558 let len = 0;
11559 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
11560 struct_ser.end()
11561 }
11562}
11563impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
11564 #[allow(deprecated)]
11565 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11566 where
11567 D: serde::Deserializer<'de>,
11568 {
11569 const FIELDS: &[&str] = &[
11570 ];
11571
11572 #[allow(clippy::enum_variant_names)]
11573 enum GeneratedField {
11574 }
11575 impl<'de> serde::Deserialize<'de> for GeneratedField {
11576 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11577 where
11578 D: serde::Deserializer<'de>,
11579 {
11580 struct GeneratedVisitor;
11581
11582 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11583 type Value = GeneratedField;
11584
11585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11586 write!(formatter, "expected one of: {:?}", &FIELDS)
11587 }
11588
11589 #[allow(unused_variables)]
11590 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11591 where
11592 E: serde::de::Error,
11593 {
11594 Err(serde::de::Error::unknown_field(value, FIELDS))
11595 }
11596 }
11597 deserializer.deserialize_identifier(GeneratedVisitor)
11598 }
11599 }
11600 struct GeneratedVisitor;
11601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11602 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
11603
11604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11605 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
11606 }
11607
11608 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
11609 where
11610 V: serde::de::MapAccess<'de>,
11611 {
11612 while map_.next_key::<GeneratedField>()?.is_some() {
11613 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11614 }
11615 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
11616 })
11617 }
11618 }
11619 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
11620 }
11621}
11622impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
11623 #[allow(deprecated)]
11624 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11625 where
11626 S: serde::Serializer,
11627 {
11628 use serde::ser::SerializeStruct;
11629 let mut len = 0;
11630 if self.summary.is_some() {
11631 len += 1;
11632 }
11633 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
11634 if let Some(v) = self.summary.as_ref() {
11635 struct_ser.serialize_field("summary", v)?;
11636 }
11637 struct_ser.end()
11638 }
11639}
11640impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
11641 #[allow(deprecated)]
11642 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11643 where
11644 D: serde::Deserializer<'de>,
11645 {
11646 const FIELDS: &[&str] = &[
11647 "summary",
11648 ];
11649
11650 #[allow(clippy::enum_variant_names)]
11651 enum GeneratedField {
11652 Summary,
11653 }
11654 impl<'de> serde::Deserialize<'de> for GeneratedField {
11655 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11656 where
11657 D: serde::Deserializer<'de>,
11658 {
11659 struct GeneratedVisitor;
11660
11661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11662 type Value = GeneratedField;
11663
11664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11665 write!(formatter, "expected one of: {:?}", &FIELDS)
11666 }
11667
11668 #[allow(unused_variables)]
11669 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11670 where
11671 E: serde::de::Error,
11672 {
11673 match value {
11674 "summary" => Ok(GeneratedField::Summary),
11675 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11676 }
11677 }
11678 }
11679 deserializer.deserialize_identifier(GeneratedVisitor)
11680 }
11681 }
11682 struct GeneratedVisitor;
11683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11684 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
11685
11686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11687 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
11688 }
11689
11690 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
11691 where
11692 V: serde::de::MapAccess<'de>,
11693 {
11694 let mut summary__ = None;
11695 while let Some(k) = map_.next_key()? {
11696 match k {
11697 GeneratedField::Summary => {
11698 if summary__.is_some() {
11699 return Err(serde::de::Error::duplicate_field("summary"));
11700 }
11701 summary__ = map_.next_value()?;
11702 }
11703 }
11704 }
11705 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
11706 summary: summary__,
11707 })
11708 }
11709 }
11710 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
11711 }
11712}
11713impl serde::Serialize for RiseCtlListCompactionGroupRequest {
11714 #[allow(deprecated)]
11715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11716 where
11717 S: serde::Serializer,
11718 {
11719 use serde::ser::SerializeStruct;
11720 let len = 0;
11721 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
11722 struct_ser.end()
11723 }
11724}
11725impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
11726 #[allow(deprecated)]
11727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11728 where
11729 D: serde::Deserializer<'de>,
11730 {
11731 const FIELDS: &[&str] = &[
11732 ];
11733
11734 #[allow(clippy::enum_variant_names)]
11735 enum GeneratedField {
11736 }
11737 impl<'de> serde::Deserialize<'de> for GeneratedField {
11738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11739 where
11740 D: serde::Deserializer<'de>,
11741 {
11742 struct GeneratedVisitor;
11743
11744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11745 type Value = GeneratedField;
11746
11747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11748 write!(formatter, "expected one of: {:?}", &FIELDS)
11749 }
11750
11751 #[allow(unused_variables)]
11752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11753 where
11754 E: serde::de::Error,
11755 {
11756 Err(serde::de::Error::unknown_field(value, FIELDS))
11757 }
11758 }
11759 deserializer.deserialize_identifier(GeneratedVisitor)
11760 }
11761 }
11762 struct GeneratedVisitor;
11763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11764 type Value = RiseCtlListCompactionGroupRequest;
11765
11766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11767 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
11768 }
11769
11770 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
11771 where
11772 V: serde::de::MapAccess<'de>,
11773 {
11774 while map_.next_key::<GeneratedField>()?.is_some() {
11775 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11776 }
11777 Ok(RiseCtlListCompactionGroupRequest {
11778 })
11779 }
11780 }
11781 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
11782 }
11783}
11784impl serde::Serialize for RiseCtlListCompactionGroupResponse {
11785 #[allow(deprecated)]
11786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11787 where
11788 S: serde::Serializer,
11789 {
11790 use serde::ser::SerializeStruct;
11791 let mut len = 0;
11792 if self.status.is_some() {
11793 len += 1;
11794 }
11795 if !self.compaction_groups.is_empty() {
11796 len += 1;
11797 }
11798 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
11799 if let Some(v) = self.status.as_ref() {
11800 struct_ser.serialize_field("status", v)?;
11801 }
11802 if !self.compaction_groups.is_empty() {
11803 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
11804 }
11805 struct_ser.end()
11806 }
11807}
11808impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
11809 #[allow(deprecated)]
11810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11811 where
11812 D: serde::Deserializer<'de>,
11813 {
11814 const FIELDS: &[&str] = &[
11815 "status",
11816 "compaction_groups",
11817 "compactionGroups",
11818 ];
11819
11820 #[allow(clippy::enum_variant_names)]
11821 enum GeneratedField {
11822 Status,
11823 CompactionGroups,
11824 }
11825 impl<'de> serde::Deserialize<'de> for GeneratedField {
11826 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11827 where
11828 D: serde::Deserializer<'de>,
11829 {
11830 struct GeneratedVisitor;
11831
11832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11833 type Value = GeneratedField;
11834
11835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11836 write!(formatter, "expected one of: {:?}", &FIELDS)
11837 }
11838
11839 #[allow(unused_variables)]
11840 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11841 where
11842 E: serde::de::Error,
11843 {
11844 match value {
11845 "status" => Ok(GeneratedField::Status),
11846 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
11847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11848 }
11849 }
11850 }
11851 deserializer.deserialize_identifier(GeneratedVisitor)
11852 }
11853 }
11854 struct GeneratedVisitor;
11855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11856 type Value = RiseCtlListCompactionGroupResponse;
11857
11858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11859 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
11860 }
11861
11862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
11863 where
11864 V: serde::de::MapAccess<'de>,
11865 {
11866 let mut status__ = None;
11867 let mut compaction_groups__ = None;
11868 while let Some(k) = map_.next_key()? {
11869 match k {
11870 GeneratedField::Status => {
11871 if status__.is_some() {
11872 return Err(serde::de::Error::duplicate_field("status"));
11873 }
11874 status__ = map_.next_value()?;
11875 }
11876 GeneratedField::CompactionGroups => {
11877 if compaction_groups__.is_some() {
11878 return Err(serde::de::Error::duplicate_field("compactionGroups"));
11879 }
11880 compaction_groups__ = Some(map_.next_value()?);
11881 }
11882 }
11883 }
11884 Ok(RiseCtlListCompactionGroupResponse {
11885 status: status__,
11886 compaction_groups: compaction_groups__.unwrap_or_default(),
11887 })
11888 }
11889 }
11890 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
11891 }
11892}
11893impl serde::Serialize for RiseCtlListCompactionStatusRequest {
11894 #[allow(deprecated)]
11895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11896 where
11897 S: serde::Serializer,
11898 {
11899 use serde::ser::SerializeStruct;
11900 let len = 0;
11901 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
11902 struct_ser.end()
11903 }
11904}
11905impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
11906 #[allow(deprecated)]
11907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11908 where
11909 D: serde::Deserializer<'de>,
11910 {
11911 const FIELDS: &[&str] = &[
11912 ];
11913
11914 #[allow(clippy::enum_variant_names)]
11915 enum GeneratedField {
11916 }
11917 impl<'de> serde::Deserialize<'de> for GeneratedField {
11918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11919 where
11920 D: serde::Deserializer<'de>,
11921 {
11922 struct GeneratedVisitor;
11923
11924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11925 type Value = GeneratedField;
11926
11927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11928 write!(formatter, "expected one of: {:?}", &FIELDS)
11929 }
11930
11931 #[allow(unused_variables)]
11932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11933 where
11934 E: serde::de::Error,
11935 {
11936 Err(serde::de::Error::unknown_field(value, FIELDS))
11937 }
11938 }
11939 deserializer.deserialize_identifier(GeneratedVisitor)
11940 }
11941 }
11942 struct GeneratedVisitor;
11943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11944 type Value = RiseCtlListCompactionStatusRequest;
11945
11946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11947 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
11948 }
11949
11950 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
11951 where
11952 V: serde::de::MapAccess<'de>,
11953 {
11954 while map_.next_key::<GeneratedField>()?.is_some() {
11955 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11956 }
11957 Ok(RiseCtlListCompactionStatusRequest {
11958 })
11959 }
11960 }
11961 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
11962 }
11963}
11964impl serde::Serialize for RiseCtlListCompactionStatusResponse {
11965 #[allow(deprecated)]
11966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11967 where
11968 S: serde::Serializer,
11969 {
11970 use serde::ser::SerializeStruct;
11971 let mut len = 0;
11972 if !self.compaction_statuses.is_empty() {
11973 len += 1;
11974 }
11975 if !self.task_assignment.is_empty() {
11976 len += 1;
11977 }
11978 if !self.task_progress.is_empty() {
11979 len += 1;
11980 }
11981 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
11982 if !self.compaction_statuses.is_empty() {
11983 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
11984 }
11985 if !self.task_assignment.is_empty() {
11986 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
11987 }
11988 if !self.task_progress.is_empty() {
11989 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
11990 }
11991 struct_ser.end()
11992 }
11993}
11994impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
11995 #[allow(deprecated)]
11996 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11997 where
11998 D: serde::Deserializer<'de>,
11999 {
12000 const FIELDS: &[&str] = &[
12001 "compaction_statuses",
12002 "compactionStatuses",
12003 "task_assignment",
12004 "taskAssignment",
12005 "task_progress",
12006 "taskProgress",
12007 ];
12008
12009 #[allow(clippy::enum_variant_names)]
12010 enum GeneratedField {
12011 CompactionStatuses,
12012 TaskAssignment,
12013 TaskProgress,
12014 }
12015 impl<'de> serde::Deserialize<'de> for GeneratedField {
12016 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12017 where
12018 D: serde::Deserializer<'de>,
12019 {
12020 struct GeneratedVisitor;
12021
12022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12023 type Value = GeneratedField;
12024
12025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12026 write!(formatter, "expected one of: {:?}", &FIELDS)
12027 }
12028
12029 #[allow(unused_variables)]
12030 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12031 where
12032 E: serde::de::Error,
12033 {
12034 match value {
12035 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
12036 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
12037 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
12038 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12039 }
12040 }
12041 }
12042 deserializer.deserialize_identifier(GeneratedVisitor)
12043 }
12044 }
12045 struct GeneratedVisitor;
12046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12047 type Value = RiseCtlListCompactionStatusResponse;
12048
12049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12050 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
12051 }
12052
12053 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
12054 where
12055 V: serde::de::MapAccess<'de>,
12056 {
12057 let mut compaction_statuses__ = None;
12058 let mut task_assignment__ = None;
12059 let mut task_progress__ = None;
12060 while let Some(k) = map_.next_key()? {
12061 match k {
12062 GeneratedField::CompactionStatuses => {
12063 if compaction_statuses__.is_some() {
12064 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
12065 }
12066 compaction_statuses__ = Some(map_.next_value()?);
12067 }
12068 GeneratedField::TaskAssignment => {
12069 if task_assignment__.is_some() {
12070 return Err(serde::de::Error::duplicate_field("taskAssignment"));
12071 }
12072 task_assignment__ = Some(map_.next_value()?);
12073 }
12074 GeneratedField::TaskProgress => {
12075 if task_progress__.is_some() {
12076 return Err(serde::de::Error::duplicate_field("taskProgress"));
12077 }
12078 task_progress__ = Some(map_.next_value()?);
12079 }
12080 }
12081 }
12082 Ok(RiseCtlListCompactionStatusResponse {
12083 compaction_statuses: compaction_statuses__.unwrap_or_default(),
12084 task_assignment: task_assignment__.unwrap_or_default(),
12085 task_progress: task_progress__.unwrap_or_default(),
12086 })
12087 }
12088 }
12089 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
12090 }
12091}
12092impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
12093 #[allow(deprecated)]
12094 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12095 where
12096 S: serde::Serializer,
12097 {
12098 use serde::ser::SerializeStruct;
12099 let len = 0;
12100 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
12101 struct_ser.end()
12102 }
12103}
12104impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
12105 #[allow(deprecated)]
12106 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12107 where
12108 D: serde::Deserializer<'de>,
12109 {
12110 const FIELDS: &[&str] = &[
12111 ];
12112
12113 #[allow(clippy::enum_variant_names)]
12114 enum GeneratedField {
12115 }
12116 impl<'de> serde::Deserialize<'de> for GeneratedField {
12117 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12118 where
12119 D: serde::Deserializer<'de>,
12120 {
12121 struct GeneratedVisitor;
12122
12123 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12124 type Value = GeneratedField;
12125
12126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12127 write!(formatter, "expected one of: {:?}", &FIELDS)
12128 }
12129
12130 #[allow(unused_variables)]
12131 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12132 where
12133 E: serde::de::Error,
12134 {
12135 Err(serde::de::Error::unknown_field(value, FIELDS))
12136 }
12137 }
12138 deserializer.deserialize_identifier(GeneratedVisitor)
12139 }
12140 }
12141 struct GeneratedVisitor;
12142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12143 type Value = RiseCtlPauseVersionCheckpointRequest;
12144
12145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12146 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
12147 }
12148
12149 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
12150 where
12151 V: serde::de::MapAccess<'de>,
12152 {
12153 while map_.next_key::<GeneratedField>()?.is_some() {
12154 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12155 }
12156 Ok(RiseCtlPauseVersionCheckpointRequest {
12157 })
12158 }
12159 }
12160 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12161 }
12162}
12163impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
12164 #[allow(deprecated)]
12165 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12166 where
12167 S: serde::Serializer,
12168 {
12169 use serde::ser::SerializeStruct;
12170 let len = 0;
12171 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
12172 struct_ser.end()
12173 }
12174}
12175impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
12176 #[allow(deprecated)]
12177 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12178 where
12179 D: serde::Deserializer<'de>,
12180 {
12181 const FIELDS: &[&str] = &[
12182 ];
12183
12184 #[allow(clippy::enum_variant_names)]
12185 enum GeneratedField {
12186 }
12187 impl<'de> serde::Deserialize<'de> for GeneratedField {
12188 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12189 where
12190 D: serde::Deserializer<'de>,
12191 {
12192 struct GeneratedVisitor;
12193
12194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12195 type Value = GeneratedField;
12196
12197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12198 write!(formatter, "expected one of: {:?}", &FIELDS)
12199 }
12200
12201 #[allow(unused_variables)]
12202 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12203 where
12204 E: serde::de::Error,
12205 {
12206 Err(serde::de::Error::unknown_field(value, FIELDS))
12207 }
12208 }
12209 deserializer.deserialize_identifier(GeneratedVisitor)
12210 }
12211 }
12212 struct GeneratedVisitor;
12213 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12214 type Value = RiseCtlPauseVersionCheckpointResponse;
12215
12216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12217 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
12218 }
12219
12220 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
12221 where
12222 V: serde::de::MapAccess<'de>,
12223 {
12224 while map_.next_key::<GeneratedField>()?.is_some() {
12225 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12226 }
12227 Ok(RiseCtlPauseVersionCheckpointResponse {
12228 })
12229 }
12230 }
12231 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
12232 }
12233}
12234impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
12235 #[allow(deprecated)]
12236 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12237 where
12238 S: serde::Serializer,
12239 {
12240 use serde::ser::SerializeStruct;
12241 let len = 0;
12242 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
12243 struct_ser.end()
12244 }
12245}
12246impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
12247 #[allow(deprecated)]
12248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12249 where
12250 D: serde::Deserializer<'de>,
12251 {
12252 const FIELDS: &[&str] = &[
12253 ];
12254
12255 #[allow(clippy::enum_variant_names)]
12256 enum GeneratedField {
12257 }
12258 impl<'de> serde::Deserialize<'de> for GeneratedField {
12259 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12260 where
12261 D: serde::Deserializer<'de>,
12262 {
12263 struct GeneratedVisitor;
12264
12265 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12266 type Value = GeneratedField;
12267
12268 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12269 write!(formatter, "expected one of: {:?}", &FIELDS)
12270 }
12271
12272 #[allow(unused_variables)]
12273 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12274 where
12275 E: serde::de::Error,
12276 {
12277 Err(serde::de::Error::unknown_field(value, FIELDS))
12278 }
12279 }
12280 deserializer.deserialize_identifier(GeneratedVisitor)
12281 }
12282 }
12283 struct GeneratedVisitor;
12284 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12285 type Value = RiseCtlRebuildTableStatsRequest;
12286
12287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12288 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
12289 }
12290
12291 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
12292 where
12293 V: serde::de::MapAccess<'de>,
12294 {
12295 while map_.next_key::<GeneratedField>()?.is_some() {
12296 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12297 }
12298 Ok(RiseCtlRebuildTableStatsRequest {
12299 })
12300 }
12301 }
12302 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
12303 }
12304}
12305impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
12306 #[allow(deprecated)]
12307 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12308 where
12309 S: serde::Serializer,
12310 {
12311 use serde::ser::SerializeStruct;
12312 let len = 0;
12313 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
12314 struct_ser.end()
12315 }
12316}
12317impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
12318 #[allow(deprecated)]
12319 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12320 where
12321 D: serde::Deserializer<'de>,
12322 {
12323 const FIELDS: &[&str] = &[
12324 ];
12325
12326 #[allow(clippy::enum_variant_names)]
12327 enum GeneratedField {
12328 }
12329 impl<'de> serde::Deserialize<'de> for GeneratedField {
12330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12331 where
12332 D: serde::Deserializer<'de>,
12333 {
12334 struct GeneratedVisitor;
12335
12336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12337 type Value = GeneratedField;
12338
12339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12340 write!(formatter, "expected one of: {:?}", &FIELDS)
12341 }
12342
12343 #[allow(unused_variables)]
12344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12345 where
12346 E: serde::de::Error,
12347 {
12348 Err(serde::de::Error::unknown_field(value, FIELDS))
12349 }
12350 }
12351 deserializer.deserialize_identifier(GeneratedVisitor)
12352 }
12353 }
12354 struct GeneratedVisitor;
12355 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12356 type Value = RiseCtlRebuildTableStatsResponse;
12357
12358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12359 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
12360 }
12361
12362 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
12363 where
12364 V: serde::de::MapAccess<'de>,
12365 {
12366 while map_.next_key::<GeneratedField>()?.is_some() {
12367 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12368 }
12369 Ok(RiseCtlRebuildTableStatsResponse {
12370 })
12371 }
12372 }
12373 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
12374 }
12375}
12376impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
12377 #[allow(deprecated)]
12378 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12379 where
12380 S: serde::Serializer,
12381 {
12382 use serde::ser::SerializeStruct;
12383 let len = 0;
12384 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
12385 struct_ser.end()
12386 }
12387}
12388impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
12389 #[allow(deprecated)]
12390 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12391 where
12392 D: serde::Deserializer<'de>,
12393 {
12394 const FIELDS: &[&str] = &[
12395 ];
12396
12397 #[allow(clippy::enum_variant_names)]
12398 enum GeneratedField {
12399 }
12400 impl<'de> serde::Deserialize<'de> for GeneratedField {
12401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12402 where
12403 D: serde::Deserializer<'de>,
12404 {
12405 struct GeneratedVisitor;
12406
12407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12408 type Value = GeneratedField;
12409
12410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12411 write!(formatter, "expected one of: {:?}", &FIELDS)
12412 }
12413
12414 #[allow(unused_variables)]
12415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12416 where
12417 E: serde::de::Error,
12418 {
12419 Err(serde::de::Error::unknown_field(value, FIELDS))
12420 }
12421 }
12422 deserializer.deserialize_identifier(GeneratedVisitor)
12423 }
12424 }
12425 struct GeneratedVisitor;
12426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12427 type Value = RiseCtlResumeVersionCheckpointRequest;
12428
12429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12430 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
12431 }
12432
12433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
12434 where
12435 V: serde::de::MapAccess<'de>,
12436 {
12437 while map_.next_key::<GeneratedField>()?.is_some() {
12438 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12439 }
12440 Ok(RiseCtlResumeVersionCheckpointRequest {
12441 })
12442 }
12443 }
12444 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12445 }
12446}
12447impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
12448 #[allow(deprecated)]
12449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12450 where
12451 S: serde::Serializer,
12452 {
12453 use serde::ser::SerializeStruct;
12454 let len = 0;
12455 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
12456 struct_ser.end()
12457 }
12458}
12459impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
12460 #[allow(deprecated)]
12461 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12462 where
12463 D: serde::Deserializer<'de>,
12464 {
12465 const FIELDS: &[&str] = &[
12466 ];
12467
12468 #[allow(clippy::enum_variant_names)]
12469 enum GeneratedField {
12470 }
12471 impl<'de> serde::Deserialize<'de> for GeneratedField {
12472 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12473 where
12474 D: serde::Deserializer<'de>,
12475 {
12476 struct GeneratedVisitor;
12477
12478 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12479 type Value = GeneratedField;
12480
12481 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12482 write!(formatter, "expected one of: {:?}", &FIELDS)
12483 }
12484
12485 #[allow(unused_variables)]
12486 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12487 where
12488 E: serde::de::Error,
12489 {
12490 Err(serde::de::Error::unknown_field(value, FIELDS))
12491 }
12492 }
12493 deserializer.deserialize_identifier(GeneratedVisitor)
12494 }
12495 }
12496 struct GeneratedVisitor;
12497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12498 type Value = RiseCtlResumeVersionCheckpointResponse;
12499
12500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12501 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
12502 }
12503
12504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
12505 where
12506 V: serde::de::MapAccess<'de>,
12507 {
12508 while map_.next_key::<GeneratedField>()?.is_some() {
12509 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12510 }
12511 Ok(RiseCtlResumeVersionCheckpointResponse {
12512 })
12513 }
12514 }
12515 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
12516 }
12517}
12518impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
12519 #[allow(deprecated)]
12520 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12521 where
12522 S: serde::Serializer,
12523 {
12524 use serde::ser::SerializeStruct;
12525 let mut len = 0;
12526 if !self.compaction_group_ids.is_empty() {
12527 len += 1;
12528 }
12529 if !self.configs.is_empty() {
12530 len += 1;
12531 }
12532 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
12533 if !self.compaction_group_ids.is_empty() {
12534 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
12535 }
12536 if !self.configs.is_empty() {
12537 struct_ser.serialize_field("configs", &self.configs)?;
12538 }
12539 struct_ser.end()
12540 }
12541}
12542impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
12543 #[allow(deprecated)]
12544 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12545 where
12546 D: serde::Deserializer<'de>,
12547 {
12548 const FIELDS: &[&str] = &[
12549 "compaction_group_ids",
12550 "compactionGroupIds",
12551 "configs",
12552 ];
12553
12554 #[allow(clippy::enum_variant_names)]
12555 enum GeneratedField {
12556 CompactionGroupIds,
12557 Configs,
12558 }
12559 impl<'de> serde::Deserialize<'de> for GeneratedField {
12560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12561 where
12562 D: serde::Deserializer<'de>,
12563 {
12564 struct GeneratedVisitor;
12565
12566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12567 type Value = GeneratedField;
12568
12569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12570 write!(formatter, "expected one of: {:?}", &FIELDS)
12571 }
12572
12573 #[allow(unused_variables)]
12574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12575 where
12576 E: serde::de::Error,
12577 {
12578 match value {
12579 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
12580 "configs" => Ok(GeneratedField::Configs),
12581 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12582 }
12583 }
12584 }
12585 deserializer.deserialize_identifier(GeneratedVisitor)
12586 }
12587 }
12588 struct GeneratedVisitor;
12589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12590 type Value = RiseCtlUpdateCompactionConfigRequest;
12591
12592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12593 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
12594 }
12595
12596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
12597 where
12598 V: serde::de::MapAccess<'de>,
12599 {
12600 let mut compaction_group_ids__ = None;
12601 let mut configs__ = None;
12602 while let Some(k) = map_.next_key()? {
12603 match k {
12604 GeneratedField::CompactionGroupIds => {
12605 if compaction_group_ids__.is_some() {
12606 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
12607 }
12608 compaction_group_ids__ =
12609 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12610 .into_iter().map(|x| x.0).collect())
12611 ;
12612 }
12613 GeneratedField::Configs => {
12614 if configs__.is_some() {
12615 return Err(serde::de::Error::duplicate_field("configs"));
12616 }
12617 configs__ = Some(map_.next_value()?);
12618 }
12619 }
12620 }
12621 Ok(RiseCtlUpdateCompactionConfigRequest {
12622 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
12623 configs: configs__.unwrap_or_default(),
12624 })
12625 }
12626 }
12627 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
12628 }
12629}
12630impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12631 #[allow(deprecated)]
12632 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12633 where
12634 S: serde::Serializer,
12635 {
12636 use serde::ser::SerializeStruct;
12637 let mut len = 0;
12638 if self.level != 0 {
12639 len += 1;
12640 }
12641 if !self.compression_algorithm.is_empty() {
12642 len += 1;
12643 }
12644 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
12645 if self.level != 0 {
12646 struct_ser.serialize_field("level", &self.level)?;
12647 }
12648 if !self.compression_algorithm.is_empty() {
12649 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
12650 }
12651 struct_ser.end()
12652 }
12653}
12654impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12655 #[allow(deprecated)]
12656 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12657 where
12658 D: serde::Deserializer<'de>,
12659 {
12660 const FIELDS: &[&str] = &[
12661 "level",
12662 "compression_algorithm",
12663 "compressionAlgorithm",
12664 ];
12665
12666 #[allow(clippy::enum_variant_names)]
12667 enum GeneratedField {
12668 Level,
12669 CompressionAlgorithm,
12670 }
12671 impl<'de> serde::Deserialize<'de> for GeneratedField {
12672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12673 where
12674 D: serde::Deserializer<'de>,
12675 {
12676 struct GeneratedVisitor;
12677
12678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12679 type Value = GeneratedField;
12680
12681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12682 write!(formatter, "expected one of: {:?}", &FIELDS)
12683 }
12684
12685 #[allow(unused_variables)]
12686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12687 where
12688 E: serde::de::Error,
12689 {
12690 match value {
12691 "level" => Ok(GeneratedField::Level),
12692 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12693 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12694 }
12695 }
12696 }
12697 deserializer.deserialize_identifier(GeneratedVisitor)
12698 }
12699 }
12700 struct GeneratedVisitor;
12701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12702 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
12703
12704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12705 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
12706 }
12707
12708 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
12709 where
12710 V: serde::de::MapAccess<'de>,
12711 {
12712 let mut level__ = None;
12713 let mut compression_algorithm__ = None;
12714 while let Some(k) = map_.next_key()? {
12715 match k {
12716 GeneratedField::Level => {
12717 if level__.is_some() {
12718 return Err(serde::de::Error::duplicate_field("level"));
12719 }
12720 level__ =
12721 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12722 ;
12723 }
12724 GeneratedField::CompressionAlgorithm => {
12725 if compression_algorithm__.is_some() {
12726 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12727 }
12728 compression_algorithm__ = Some(map_.next_value()?);
12729 }
12730 }
12731 }
12732 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12733 level: level__.unwrap_or_default(),
12734 compression_algorithm: compression_algorithm__.unwrap_or_default(),
12735 })
12736 }
12737 }
12738 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
12739 }
12740}
12741impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
12742 #[allow(deprecated)]
12743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12744 where
12745 S: serde::Serializer,
12746 {
12747 use serde::ser::SerializeStruct;
12748 let mut len = 0;
12749 if self.mutable_config.is_some() {
12750 len += 1;
12751 }
12752 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
12753 if let Some(v) = self.mutable_config.as_ref() {
12754 match v {
12755 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
12756 #[allow(clippy::needless_borrow)]
12757 #[allow(clippy::needless_borrows_for_generic_args)]
12758 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
12759 }
12760 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
12761 #[allow(clippy::needless_borrow)]
12762 #[allow(clippy::needless_borrows_for_generic_args)]
12763 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
12764 }
12765 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
12766 #[allow(clippy::needless_borrow)]
12767 #[allow(clippy::needless_borrows_for_generic_args)]
12768 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
12769 }
12770 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
12771 #[allow(clippy::needless_borrow)]
12772 #[allow(clippy::needless_borrows_for_generic_args)]
12773 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
12774 }
12775 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
12776 #[allow(clippy::needless_borrow)]
12777 #[allow(clippy::needless_borrows_for_generic_args)]
12778 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
12779 }
12780 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
12781 #[allow(clippy::needless_borrow)]
12782 #[allow(clippy::needless_borrows_for_generic_args)]
12783 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
12784 }
12785 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
12786 struct_ser.serialize_field("compactionFilterMask", v)?;
12787 }
12788 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
12789 struct_ser.serialize_field("maxSubCompaction", v)?;
12790 }
12791 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
12792 #[allow(clippy::needless_borrow)]
12793 #[allow(clippy::needless_borrows_for_generic_args)]
12794 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
12795 }
12796 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
12797 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
12798 }
12799 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
12800 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
12801 }
12802 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
12803 #[allow(clippy::needless_borrow)]
12804 #[allow(clippy::needless_borrows_for_generic_args)]
12805 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
12806 }
12807 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
12808 #[allow(clippy::needless_borrow)]
12809 #[allow(clippy::needless_borrows_for_generic_args)]
12810 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
12811 }
12812 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
12813 struct_ser.serialize_field("enableEmergencyPicker", v)?;
12814 }
12815 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
12816 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
12817 }
12818 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
12819 struct_ser.serialize_field("compressionAlgorithm", v)?;
12820 }
12821 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
12822 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
12823 }
12824 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
12825 #[allow(clippy::needless_borrow)]
12826 #[allow(clippy::needless_borrows_for_generic_args)]
12827 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
12828 }
12829 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
12830 struct_ser.serialize_field("splitWeightByVnode", v)?;
12831 }
12832 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
12833 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
12834 }
12835 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
12836 #[allow(clippy::needless_borrow)]
12837 #[allow(clippy::needless_borrows_for_generic_args)]
12838 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
12839 }
12840 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
12841 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
12842 }
12843 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
12844 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
12845 }
12846 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
12847 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
12848 }
12849 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
12850 #[allow(clippy::needless_borrow)]
12851 #[allow(clippy::needless_borrows_for_generic_args)]
12852 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
12853 }
12854 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
12855 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
12856 }
12857 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
12858 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
12859 }
12860 }
12861 }
12862 struct_ser.end()
12863 }
12864}
12865impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
12866 #[allow(deprecated)]
12867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12868 where
12869 D: serde::Deserializer<'de>,
12870 {
12871 const FIELDS: &[&str] = &[
12872 "max_bytes_for_level_base",
12873 "maxBytesForLevelBase",
12874 "max_bytes_for_level_multiplier",
12875 "maxBytesForLevelMultiplier",
12876 "max_compaction_bytes",
12877 "maxCompactionBytes",
12878 "sub_level_max_compaction_bytes",
12879 "subLevelMaxCompactionBytes",
12880 "level0_tier_compact_file_number",
12881 "level0TierCompactFileNumber",
12882 "target_file_size_base",
12883 "targetFileSizeBase",
12884 "compaction_filter_mask",
12885 "compactionFilterMask",
12886 "max_sub_compaction",
12887 "maxSubCompaction",
12888 "level0_stop_write_threshold_sub_level_number",
12889 "level0StopWriteThresholdSubLevelNumber",
12890 "level0_sub_level_compact_level_count",
12891 "level0SubLevelCompactLevelCount",
12892 "level0_overlapping_sub_level_compact_level_count",
12893 "level0OverlappingSubLevelCompactLevelCount",
12894 "max_space_reclaim_bytes",
12895 "maxSpaceReclaimBytes",
12896 "level0_max_compact_file_number",
12897 "level0MaxCompactFileNumber",
12898 "enable_emergency_picker",
12899 "enableEmergencyPicker",
12900 "tombstone_reclaim_ratio",
12901 "tombstoneReclaimRatio",
12902 "compression_algorithm",
12903 "compressionAlgorithm",
12904 "max_l0_compact_level_count",
12905 "maxL0CompactLevelCount",
12906 "sst_allowed_trivial_move_min_size",
12907 "sstAllowedTrivialMoveMinSize",
12908 "split_weight_by_vnode",
12909 "splitWeightByVnode",
12910 "disable_auto_group_scheduling",
12911 "disableAutoGroupScheduling",
12912 "max_overlapping_level_size",
12913 "maxOverlappingLevelSize",
12914 "emergency_level0_sst_file_count",
12915 "emergencyLevel0SstFileCount",
12916 "emergency_level0_sub_level_partition",
12917 "emergencyLevel0SubLevelPartition",
12918 "level0_stop_write_threshold_max_sst_count",
12919 "level0StopWriteThresholdMaxSstCount",
12920 "level0_stop_write_threshold_max_size",
12921 "level0StopWriteThresholdMaxSize",
12922 "sst_allowed_trivial_move_max_count",
12923 "sstAllowedTrivialMoveMaxCount",
12924 "enable_optimize_l0_interval_selection",
12925 "enableOptimizeL0IntervalSelection",
12926 ];
12927
12928 #[allow(clippy::enum_variant_names)]
12929 enum GeneratedField {
12930 MaxBytesForLevelBase,
12931 MaxBytesForLevelMultiplier,
12932 MaxCompactionBytes,
12933 SubLevelMaxCompactionBytes,
12934 Level0TierCompactFileNumber,
12935 TargetFileSizeBase,
12936 CompactionFilterMask,
12937 MaxSubCompaction,
12938 Level0StopWriteThresholdSubLevelNumber,
12939 Level0SubLevelCompactLevelCount,
12940 Level0OverlappingSubLevelCompactLevelCount,
12941 MaxSpaceReclaimBytes,
12942 Level0MaxCompactFileNumber,
12943 EnableEmergencyPicker,
12944 TombstoneReclaimRatio,
12945 CompressionAlgorithm,
12946 MaxL0CompactLevelCount,
12947 SstAllowedTrivialMoveMinSize,
12948 SplitWeightByVnode,
12949 DisableAutoGroupScheduling,
12950 MaxOverlappingLevelSize,
12951 EmergencyLevel0SstFileCount,
12952 EmergencyLevel0SubLevelPartition,
12953 Level0StopWriteThresholdMaxSstCount,
12954 Level0StopWriteThresholdMaxSize,
12955 SstAllowedTrivialMoveMaxCount,
12956 EnableOptimizeL0IntervalSelection,
12957 }
12958 impl<'de> serde::Deserialize<'de> for GeneratedField {
12959 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12960 where
12961 D: serde::Deserializer<'de>,
12962 {
12963 struct GeneratedVisitor;
12964
12965 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12966 type Value = GeneratedField;
12967
12968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12969 write!(formatter, "expected one of: {:?}", &FIELDS)
12970 }
12971
12972 #[allow(unused_variables)]
12973 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12974 where
12975 E: serde::de::Error,
12976 {
12977 match value {
12978 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
12979 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
12980 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
12981 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
12982 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
12983 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
12984 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
12985 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
12986 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
12987 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
12988 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
12989 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
12990 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
12991 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
12992 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
12993 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12994 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
12995 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
12996 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
12997 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
12998 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
12999 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
13000 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
13001 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
13002 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
13003 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
13004 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
13005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13006 }
13007 }
13008 }
13009 deserializer.deserialize_identifier(GeneratedVisitor)
13010 }
13011 }
13012 struct GeneratedVisitor;
13013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13014 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
13015
13016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13017 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
13018 }
13019
13020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
13021 where
13022 V: serde::de::MapAccess<'de>,
13023 {
13024 let mut mutable_config__ = None;
13025 while let Some(k) = map_.next_key()? {
13026 match k {
13027 GeneratedField::MaxBytesForLevelBase => {
13028 if mutable_config__.is_some() {
13029 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
13030 }
13031 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));
13032 }
13033 GeneratedField::MaxBytesForLevelMultiplier => {
13034 if mutable_config__.is_some() {
13035 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
13036 }
13037 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));
13038 }
13039 GeneratedField::MaxCompactionBytes => {
13040 if mutable_config__.is_some() {
13041 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
13042 }
13043 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));
13044 }
13045 GeneratedField::SubLevelMaxCompactionBytes => {
13046 if mutable_config__.is_some() {
13047 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
13048 }
13049 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));
13050 }
13051 GeneratedField::Level0TierCompactFileNumber => {
13052 if mutable_config__.is_some() {
13053 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
13054 }
13055 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));
13056 }
13057 GeneratedField::TargetFileSizeBase => {
13058 if mutable_config__.is_some() {
13059 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
13060 }
13061 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));
13062 }
13063 GeneratedField::CompactionFilterMask => {
13064 if mutable_config__.is_some() {
13065 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
13066 }
13067 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));
13068 }
13069 GeneratedField::MaxSubCompaction => {
13070 if mutable_config__.is_some() {
13071 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
13072 }
13073 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));
13074 }
13075 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
13076 if mutable_config__.is_some() {
13077 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
13078 }
13079 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));
13080 }
13081 GeneratedField::Level0SubLevelCompactLevelCount => {
13082 if mutable_config__.is_some() {
13083 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
13084 }
13085 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));
13086 }
13087 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
13088 if mutable_config__.is_some() {
13089 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
13090 }
13091 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));
13092 }
13093 GeneratedField::MaxSpaceReclaimBytes => {
13094 if mutable_config__.is_some() {
13095 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
13096 }
13097 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));
13098 }
13099 GeneratedField::Level0MaxCompactFileNumber => {
13100 if mutable_config__.is_some() {
13101 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
13102 }
13103 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));
13104 }
13105 GeneratedField::EnableEmergencyPicker => {
13106 if mutable_config__.is_some() {
13107 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
13108 }
13109 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
13110 }
13111 GeneratedField::TombstoneReclaimRatio => {
13112 if mutable_config__.is_some() {
13113 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
13114 }
13115 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));
13116 }
13117 GeneratedField::CompressionAlgorithm => {
13118 if mutable_config__.is_some() {
13119 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13120 }
13121 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
13122;
13123 }
13124 GeneratedField::MaxL0CompactLevelCount => {
13125 if mutable_config__.is_some() {
13126 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
13127 }
13128 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));
13129 }
13130 GeneratedField::SstAllowedTrivialMoveMinSize => {
13131 if mutable_config__.is_some() {
13132 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
13133 }
13134 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));
13135 }
13136 GeneratedField::SplitWeightByVnode => {
13137 if mutable_config__.is_some() {
13138 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
13139 }
13140 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));
13141 }
13142 GeneratedField::DisableAutoGroupScheduling => {
13143 if mutable_config__.is_some() {
13144 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
13145 }
13146 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
13147 }
13148 GeneratedField::MaxOverlappingLevelSize => {
13149 if mutable_config__.is_some() {
13150 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
13151 }
13152 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));
13153 }
13154 GeneratedField::EmergencyLevel0SstFileCount => {
13155 if mutable_config__.is_some() {
13156 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
13157 }
13158 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));
13159 }
13160 GeneratedField::EmergencyLevel0SubLevelPartition => {
13161 if mutable_config__.is_some() {
13162 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
13163 }
13164 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));
13165 }
13166 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
13167 if mutable_config__.is_some() {
13168 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
13169 }
13170 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));
13171 }
13172 GeneratedField::Level0StopWriteThresholdMaxSize => {
13173 if mutable_config__.is_some() {
13174 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
13175 }
13176 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));
13177 }
13178 GeneratedField::SstAllowedTrivialMoveMaxCount => {
13179 if mutable_config__.is_some() {
13180 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
13181 }
13182 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));
13183 }
13184 GeneratedField::EnableOptimizeL0IntervalSelection => {
13185 if mutable_config__.is_some() {
13186 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
13187 }
13188 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
13189 }
13190 }
13191 }
13192 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
13193 mutable_config: mutable_config__,
13194 })
13195 }
13196 }
13197 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
13198 }
13199}
13200impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
13201 #[allow(deprecated)]
13202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13203 where
13204 S: serde::Serializer,
13205 {
13206 use serde::ser::SerializeStruct;
13207 let mut len = 0;
13208 if self.status.is_some() {
13209 len += 1;
13210 }
13211 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
13212 if let Some(v) = self.status.as_ref() {
13213 struct_ser.serialize_field("status", v)?;
13214 }
13215 struct_ser.end()
13216 }
13217}
13218impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
13219 #[allow(deprecated)]
13220 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13221 where
13222 D: serde::Deserializer<'de>,
13223 {
13224 const FIELDS: &[&str] = &[
13225 "status",
13226 ];
13227
13228 #[allow(clippy::enum_variant_names)]
13229 enum GeneratedField {
13230 Status,
13231 }
13232 impl<'de> serde::Deserialize<'de> for GeneratedField {
13233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13234 where
13235 D: serde::Deserializer<'de>,
13236 {
13237 struct GeneratedVisitor;
13238
13239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13240 type Value = GeneratedField;
13241
13242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13243 write!(formatter, "expected one of: {:?}", &FIELDS)
13244 }
13245
13246 #[allow(unused_variables)]
13247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13248 where
13249 E: serde::de::Error,
13250 {
13251 match value {
13252 "status" => Ok(GeneratedField::Status),
13253 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13254 }
13255 }
13256 }
13257 deserializer.deserialize_identifier(GeneratedVisitor)
13258 }
13259 }
13260 struct GeneratedVisitor;
13261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13262 type Value = RiseCtlUpdateCompactionConfigResponse;
13263
13264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13265 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
13266 }
13267
13268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
13269 where
13270 V: serde::de::MapAccess<'de>,
13271 {
13272 let mut status__ = None;
13273 while let Some(k) = map_.next_key()? {
13274 match k {
13275 GeneratedField::Status => {
13276 if status__.is_some() {
13277 return Err(serde::de::Error::duplicate_field("status"));
13278 }
13279 status__ = map_.next_value()?;
13280 }
13281 }
13282 }
13283 Ok(RiseCtlUpdateCompactionConfigResponse {
13284 status: status__,
13285 })
13286 }
13287 }
13288 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
13289 }
13290}
13291impl serde::Serialize for SplitCompactionGroupRequest {
13292 #[allow(deprecated)]
13293 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13294 where
13295 S: serde::Serializer,
13296 {
13297 use serde::ser::SerializeStruct;
13298 let mut len = 0;
13299 if self.group_id != 0 {
13300 len += 1;
13301 }
13302 if !self.table_ids.is_empty() {
13303 len += 1;
13304 }
13305 if self.partition_vnode_count != 0 {
13306 len += 1;
13307 }
13308 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
13309 if self.group_id != 0 {
13310 #[allow(clippy::needless_borrow)]
13311 #[allow(clippy::needless_borrows_for_generic_args)]
13312 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
13313 }
13314 if !self.table_ids.is_empty() {
13315 struct_ser.serialize_field("tableIds", &self.table_ids)?;
13316 }
13317 if self.partition_vnode_count != 0 {
13318 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
13319 }
13320 struct_ser.end()
13321 }
13322}
13323impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
13324 #[allow(deprecated)]
13325 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13326 where
13327 D: serde::Deserializer<'de>,
13328 {
13329 const FIELDS: &[&str] = &[
13330 "group_id",
13331 "groupId",
13332 "table_ids",
13333 "tableIds",
13334 "partition_vnode_count",
13335 "partitionVnodeCount",
13336 ];
13337
13338 #[allow(clippy::enum_variant_names)]
13339 enum GeneratedField {
13340 GroupId,
13341 TableIds,
13342 PartitionVnodeCount,
13343 }
13344 impl<'de> serde::Deserialize<'de> for GeneratedField {
13345 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13346 where
13347 D: serde::Deserializer<'de>,
13348 {
13349 struct GeneratedVisitor;
13350
13351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13352 type Value = GeneratedField;
13353
13354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13355 write!(formatter, "expected one of: {:?}", &FIELDS)
13356 }
13357
13358 #[allow(unused_variables)]
13359 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13360 where
13361 E: serde::de::Error,
13362 {
13363 match value {
13364 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
13365 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13366 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
13367 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13368 }
13369 }
13370 }
13371 deserializer.deserialize_identifier(GeneratedVisitor)
13372 }
13373 }
13374 struct GeneratedVisitor;
13375 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13376 type Value = SplitCompactionGroupRequest;
13377
13378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13379 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
13380 }
13381
13382 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
13383 where
13384 V: serde::de::MapAccess<'de>,
13385 {
13386 let mut group_id__ = None;
13387 let mut table_ids__ = None;
13388 let mut partition_vnode_count__ = None;
13389 while let Some(k) = map_.next_key()? {
13390 match k {
13391 GeneratedField::GroupId => {
13392 if group_id__.is_some() {
13393 return Err(serde::de::Error::duplicate_field("groupId"));
13394 }
13395 group_id__ =
13396 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13397 ;
13398 }
13399 GeneratedField::TableIds => {
13400 if table_ids__.is_some() {
13401 return Err(serde::de::Error::duplicate_field("tableIds"));
13402 }
13403 table_ids__ =
13404 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13405 .into_iter().map(|x| x.0).collect())
13406 ;
13407 }
13408 GeneratedField::PartitionVnodeCount => {
13409 if partition_vnode_count__.is_some() {
13410 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
13411 }
13412 partition_vnode_count__ =
13413 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13414 ;
13415 }
13416 }
13417 }
13418 Ok(SplitCompactionGroupRequest {
13419 group_id: group_id__.unwrap_or_default(),
13420 table_ids: table_ids__.unwrap_or_default(),
13421 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
13422 })
13423 }
13424 }
13425 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
13426 }
13427}
13428impl serde::Serialize for SplitCompactionGroupResponse {
13429 #[allow(deprecated)]
13430 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13431 where
13432 S: serde::Serializer,
13433 {
13434 use serde::ser::SerializeStruct;
13435 let mut len = 0;
13436 if self.new_group_id != 0 {
13437 len += 1;
13438 }
13439 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
13440 if self.new_group_id != 0 {
13441 #[allow(clippy::needless_borrow)]
13442 #[allow(clippy::needless_borrows_for_generic_args)]
13443 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
13444 }
13445 struct_ser.end()
13446 }
13447}
13448impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
13449 #[allow(deprecated)]
13450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13451 where
13452 D: serde::Deserializer<'de>,
13453 {
13454 const FIELDS: &[&str] = &[
13455 "new_group_id",
13456 "newGroupId",
13457 ];
13458
13459 #[allow(clippy::enum_variant_names)]
13460 enum GeneratedField {
13461 NewGroupId,
13462 }
13463 impl<'de> serde::Deserialize<'de> for GeneratedField {
13464 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13465 where
13466 D: serde::Deserializer<'de>,
13467 {
13468 struct GeneratedVisitor;
13469
13470 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13471 type Value = GeneratedField;
13472
13473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13474 write!(formatter, "expected one of: {:?}", &FIELDS)
13475 }
13476
13477 #[allow(unused_variables)]
13478 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13479 where
13480 E: serde::de::Error,
13481 {
13482 match value {
13483 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
13484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13485 }
13486 }
13487 }
13488 deserializer.deserialize_identifier(GeneratedVisitor)
13489 }
13490 }
13491 struct GeneratedVisitor;
13492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13493 type Value = SplitCompactionGroupResponse;
13494
13495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13496 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
13497 }
13498
13499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
13500 where
13501 V: serde::de::MapAccess<'de>,
13502 {
13503 let mut new_group_id__ = None;
13504 while let Some(k) = map_.next_key()? {
13505 match k {
13506 GeneratedField::NewGroupId => {
13507 if new_group_id__.is_some() {
13508 return Err(serde::de::Error::duplicate_field("newGroupId"));
13509 }
13510 new_group_id__ =
13511 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13512 ;
13513 }
13514 }
13515 }
13516 Ok(SplitCompactionGroupResponse {
13517 new_group_id: new_group_id__.unwrap_or_default(),
13518 })
13519 }
13520 }
13521 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
13522 }
13523}
13524impl serde::Serialize for SstableInfo {
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.object_id != 0 {
13533 len += 1;
13534 }
13535 if self.sst_id != 0 {
13536 len += 1;
13537 }
13538 if self.key_range.is_some() {
13539 len += 1;
13540 }
13541 if self.file_size != 0 {
13542 len += 1;
13543 }
13544 if !self.table_ids.is_empty() {
13545 len += 1;
13546 }
13547 if self.meta_offset != 0 {
13548 len += 1;
13549 }
13550 if self.stale_key_count != 0 {
13551 len += 1;
13552 }
13553 if self.total_key_count != 0 {
13554 len += 1;
13555 }
13556 if self.min_epoch != 0 {
13557 len += 1;
13558 }
13559 if self.max_epoch != 0 {
13560 len += 1;
13561 }
13562 if self.uncompressed_file_size != 0 {
13563 len += 1;
13564 }
13565 if self.range_tombstone_count != 0 {
13566 len += 1;
13567 }
13568 if self.bloom_filter_kind != 0 {
13569 len += 1;
13570 }
13571 if self.sst_size != 0 {
13572 len += 1;
13573 }
13574 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
13575 if self.object_id != 0 {
13576 #[allow(clippy::needless_borrow)]
13577 #[allow(clippy::needless_borrows_for_generic_args)]
13578 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
13579 }
13580 if self.sst_id != 0 {
13581 #[allow(clippy::needless_borrow)]
13582 #[allow(clippy::needless_borrows_for_generic_args)]
13583 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
13584 }
13585 if let Some(v) = self.key_range.as_ref() {
13586 struct_ser.serialize_field("keyRange", v)?;
13587 }
13588 if self.file_size != 0 {
13589 #[allow(clippy::needless_borrow)]
13590 #[allow(clippy::needless_borrows_for_generic_args)]
13591 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
13592 }
13593 if !self.table_ids.is_empty() {
13594 struct_ser.serialize_field("tableIds", &self.table_ids)?;
13595 }
13596 if self.meta_offset != 0 {
13597 #[allow(clippy::needless_borrow)]
13598 #[allow(clippy::needless_borrows_for_generic_args)]
13599 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
13600 }
13601 if self.stale_key_count != 0 {
13602 #[allow(clippy::needless_borrow)]
13603 #[allow(clippy::needless_borrows_for_generic_args)]
13604 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
13605 }
13606 if self.total_key_count != 0 {
13607 #[allow(clippy::needless_borrow)]
13608 #[allow(clippy::needless_borrows_for_generic_args)]
13609 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
13610 }
13611 if self.min_epoch != 0 {
13612 #[allow(clippy::needless_borrow)]
13613 #[allow(clippy::needless_borrows_for_generic_args)]
13614 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
13615 }
13616 if self.max_epoch != 0 {
13617 #[allow(clippy::needless_borrow)]
13618 #[allow(clippy::needless_borrows_for_generic_args)]
13619 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
13620 }
13621 if self.uncompressed_file_size != 0 {
13622 #[allow(clippy::needless_borrow)]
13623 #[allow(clippy::needless_borrows_for_generic_args)]
13624 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
13625 }
13626 if self.range_tombstone_count != 0 {
13627 #[allow(clippy::needless_borrow)]
13628 #[allow(clippy::needless_borrows_for_generic_args)]
13629 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
13630 }
13631 if self.bloom_filter_kind != 0 {
13632 let v = BloomFilterType::try_from(self.bloom_filter_kind)
13633 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
13634 struct_ser.serialize_field("bloomFilterKind", &v)?;
13635 }
13636 if self.sst_size != 0 {
13637 #[allow(clippy::needless_borrow)]
13638 #[allow(clippy::needless_borrows_for_generic_args)]
13639 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
13640 }
13641 struct_ser.end()
13642 }
13643}
13644impl<'de> serde::Deserialize<'de> for SstableInfo {
13645 #[allow(deprecated)]
13646 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13647 where
13648 D: serde::Deserializer<'de>,
13649 {
13650 const FIELDS: &[&str] = &[
13651 "object_id",
13652 "objectId",
13653 "sst_id",
13654 "sstId",
13655 "key_range",
13656 "keyRange",
13657 "file_size",
13658 "fileSize",
13659 "table_ids",
13660 "tableIds",
13661 "meta_offset",
13662 "metaOffset",
13663 "stale_key_count",
13664 "staleKeyCount",
13665 "total_key_count",
13666 "totalKeyCount",
13667 "min_epoch",
13668 "minEpoch",
13669 "max_epoch",
13670 "maxEpoch",
13671 "uncompressed_file_size",
13672 "uncompressedFileSize",
13673 "range_tombstone_count",
13674 "rangeTombstoneCount",
13675 "bloom_filter_kind",
13676 "bloomFilterKind",
13677 "sst_size",
13678 "sstSize",
13679 ];
13680
13681 #[allow(clippy::enum_variant_names)]
13682 enum GeneratedField {
13683 ObjectId,
13684 SstId,
13685 KeyRange,
13686 FileSize,
13687 TableIds,
13688 MetaOffset,
13689 StaleKeyCount,
13690 TotalKeyCount,
13691 MinEpoch,
13692 MaxEpoch,
13693 UncompressedFileSize,
13694 RangeTombstoneCount,
13695 BloomFilterKind,
13696 SstSize,
13697 }
13698 impl<'de> serde::Deserialize<'de> for GeneratedField {
13699 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13700 where
13701 D: serde::Deserializer<'de>,
13702 {
13703 struct GeneratedVisitor;
13704
13705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13706 type Value = GeneratedField;
13707
13708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13709 write!(formatter, "expected one of: {:?}", &FIELDS)
13710 }
13711
13712 #[allow(unused_variables)]
13713 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13714 where
13715 E: serde::de::Error,
13716 {
13717 match value {
13718 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
13719 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
13720 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
13721 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
13722 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13723 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
13724 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
13725 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
13726 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
13727 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
13728 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
13729 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
13730 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
13731 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
13732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13733 }
13734 }
13735 }
13736 deserializer.deserialize_identifier(GeneratedVisitor)
13737 }
13738 }
13739 struct GeneratedVisitor;
13740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13741 type Value = SstableInfo;
13742
13743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13744 formatter.write_str("struct hummock.SstableInfo")
13745 }
13746
13747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
13748 where
13749 V: serde::de::MapAccess<'de>,
13750 {
13751 let mut object_id__ = None;
13752 let mut sst_id__ = None;
13753 let mut key_range__ = None;
13754 let mut file_size__ = None;
13755 let mut table_ids__ = None;
13756 let mut meta_offset__ = None;
13757 let mut stale_key_count__ = None;
13758 let mut total_key_count__ = None;
13759 let mut min_epoch__ = None;
13760 let mut max_epoch__ = None;
13761 let mut uncompressed_file_size__ = None;
13762 let mut range_tombstone_count__ = None;
13763 let mut bloom_filter_kind__ = None;
13764 let mut sst_size__ = None;
13765 while let Some(k) = map_.next_key()? {
13766 match k {
13767 GeneratedField::ObjectId => {
13768 if object_id__.is_some() {
13769 return Err(serde::de::Error::duplicate_field("objectId"));
13770 }
13771 object_id__ =
13772 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13773 ;
13774 }
13775 GeneratedField::SstId => {
13776 if sst_id__.is_some() {
13777 return Err(serde::de::Error::duplicate_field("sstId"));
13778 }
13779 sst_id__ =
13780 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13781 ;
13782 }
13783 GeneratedField::KeyRange => {
13784 if key_range__.is_some() {
13785 return Err(serde::de::Error::duplicate_field("keyRange"));
13786 }
13787 key_range__ = map_.next_value()?;
13788 }
13789 GeneratedField::FileSize => {
13790 if file_size__.is_some() {
13791 return Err(serde::de::Error::duplicate_field("fileSize"));
13792 }
13793 file_size__ =
13794 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13795 ;
13796 }
13797 GeneratedField::TableIds => {
13798 if table_ids__.is_some() {
13799 return Err(serde::de::Error::duplicate_field("tableIds"));
13800 }
13801 table_ids__ =
13802 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13803 .into_iter().map(|x| x.0).collect())
13804 ;
13805 }
13806 GeneratedField::MetaOffset => {
13807 if meta_offset__.is_some() {
13808 return Err(serde::de::Error::duplicate_field("metaOffset"));
13809 }
13810 meta_offset__ =
13811 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13812 ;
13813 }
13814 GeneratedField::StaleKeyCount => {
13815 if stale_key_count__.is_some() {
13816 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
13817 }
13818 stale_key_count__ =
13819 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13820 ;
13821 }
13822 GeneratedField::TotalKeyCount => {
13823 if total_key_count__.is_some() {
13824 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
13825 }
13826 total_key_count__ =
13827 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13828 ;
13829 }
13830 GeneratedField::MinEpoch => {
13831 if min_epoch__.is_some() {
13832 return Err(serde::de::Error::duplicate_field("minEpoch"));
13833 }
13834 min_epoch__ =
13835 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13836 ;
13837 }
13838 GeneratedField::MaxEpoch => {
13839 if max_epoch__.is_some() {
13840 return Err(serde::de::Error::duplicate_field("maxEpoch"));
13841 }
13842 max_epoch__ =
13843 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13844 ;
13845 }
13846 GeneratedField::UncompressedFileSize => {
13847 if uncompressed_file_size__.is_some() {
13848 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
13849 }
13850 uncompressed_file_size__ =
13851 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13852 ;
13853 }
13854 GeneratedField::RangeTombstoneCount => {
13855 if range_tombstone_count__.is_some() {
13856 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
13857 }
13858 range_tombstone_count__ =
13859 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13860 ;
13861 }
13862 GeneratedField::BloomFilterKind => {
13863 if bloom_filter_kind__.is_some() {
13864 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
13865 }
13866 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
13867 }
13868 GeneratedField::SstSize => {
13869 if sst_size__.is_some() {
13870 return Err(serde::de::Error::duplicate_field("sstSize"));
13871 }
13872 sst_size__ =
13873 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13874 ;
13875 }
13876 }
13877 }
13878 Ok(SstableInfo {
13879 object_id: object_id__.unwrap_or_default(),
13880 sst_id: sst_id__.unwrap_or_default(),
13881 key_range: key_range__,
13882 file_size: file_size__.unwrap_or_default(),
13883 table_ids: table_ids__.unwrap_or_default(),
13884 meta_offset: meta_offset__.unwrap_or_default(),
13885 stale_key_count: stale_key_count__.unwrap_or_default(),
13886 total_key_count: total_key_count__.unwrap_or_default(),
13887 min_epoch: min_epoch__.unwrap_or_default(),
13888 max_epoch: max_epoch__.unwrap_or_default(),
13889 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
13890 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
13891 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
13892 sst_size: sst_size__.unwrap_or_default(),
13893 })
13894 }
13895 }
13896 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
13897 }
13898}
13899impl serde::Serialize for StateTableInfo {
13900 #[allow(deprecated)]
13901 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13902 where
13903 S: serde::Serializer,
13904 {
13905 use serde::ser::SerializeStruct;
13906 let mut len = 0;
13907 if self.committed_epoch != 0 {
13908 len += 1;
13909 }
13910 if self.compaction_group_id != 0 {
13911 len += 1;
13912 }
13913 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
13914 if self.committed_epoch != 0 {
13915 #[allow(clippy::needless_borrow)]
13916 #[allow(clippy::needless_borrows_for_generic_args)]
13917 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13918 }
13919 if self.compaction_group_id != 0 {
13920 #[allow(clippy::needless_borrow)]
13921 #[allow(clippy::needless_borrows_for_generic_args)]
13922 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13923 }
13924 struct_ser.end()
13925 }
13926}
13927impl<'de> serde::Deserialize<'de> for StateTableInfo {
13928 #[allow(deprecated)]
13929 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13930 where
13931 D: serde::Deserializer<'de>,
13932 {
13933 const FIELDS: &[&str] = &[
13934 "committed_epoch",
13935 "committedEpoch",
13936 "compaction_group_id",
13937 "compactionGroupId",
13938 ];
13939
13940 #[allow(clippy::enum_variant_names)]
13941 enum GeneratedField {
13942 CommittedEpoch,
13943 CompactionGroupId,
13944 }
13945 impl<'de> serde::Deserialize<'de> for GeneratedField {
13946 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13947 where
13948 D: serde::Deserializer<'de>,
13949 {
13950 struct GeneratedVisitor;
13951
13952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13953 type Value = GeneratedField;
13954
13955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13956 write!(formatter, "expected one of: {:?}", &FIELDS)
13957 }
13958
13959 #[allow(unused_variables)]
13960 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13961 where
13962 E: serde::de::Error,
13963 {
13964 match value {
13965 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13966 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13967 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13968 }
13969 }
13970 }
13971 deserializer.deserialize_identifier(GeneratedVisitor)
13972 }
13973 }
13974 struct GeneratedVisitor;
13975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13976 type Value = StateTableInfo;
13977
13978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13979 formatter.write_str("struct hummock.StateTableInfo")
13980 }
13981
13982 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
13983 where
13984 V: serde::de::MapAccess<'de>,
13985 {
13986 let mut committed_epoch__ = None;
13987 let mut compaction_group_id__ = None;
13988 while let Some(k) = map_.next_key()? {
13989 match k {
13990 GeneratedField::CommittedEpoch => {
13991 if committed_epoch__.is_some() {
13992 return Err(serde::de::Error::duplicate_field("committedEpoch"));
13993 }
13994 committed_epoch__ =
13995 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13996 ;
13997 }
13998 GeneratedField::CompactionGroupId => {
13999 if compaction_group_id__.is_some() {
14000 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14001 }
14002 compaction_group_id__ =
14003 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14004 ;
14005 }
14006 }
14007 }
14008 Ok(StateTableInfo {
14009 committed_epoch: committed_epoch__.unwrap_or_default(),
14010 compaction_group_id: compaction_group_id__.unwrap_or_default(),
14011 })
14012 }
14013 }
14014 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
14015 }
14016}
14017impl serde::Serialize for StateTableInfoDelta {
14018 #[allow(deprecated)]
14019 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14020 where
14021 S: serde::Serializer,
14022 {
14023 use serde::ser::SerializeStruct;
14024 let mut len = 0;
14025 if self.committed_epoch != 0 {
14026 len += 1;
14027 }
14028 if self.compaction_group_id != 0 {
14029 len += 1;
14030 }
14031 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
14032 if self.committed_epoch != 0 {
14033 #[allow(clippy::needless_borrow)]
14034 #[allow(clippy::needless_borrows_for_generic_args)]
14035 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
14036 }
14037 if self.compaction_group_id != 0 {
14038 #[allow(clippy::needless_borrow)]
14039 #[allow(clippy::needless_borrows_for_generic_args)]
14040 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
14041 }
14042 struct_ser.end()
14043 }
14044}
14045impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
14046 #[allow(deprecated)]
14047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14048 where
14049 D: serde::Deserializer<'de>,
14050 {
14051 const FIELDS: &[&str] = &[
14052 "committed_epoch",
14053 "committedEpoch",
14054 "compaction_group_id",
14055 "compactionGroupId",
14056 ];
14057
14058 #[allow(clippy::enum_variant_names)]
14059 enum GeneratedField {
14060 CommittedEpoch,
14061 CompactionGroupId,
14062 }
14063 impl<'de> serde::Deserialize<'de> for GeneratedField {
14064 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14065 where
14066 D: serde::Deserializer<'de>,
14067 {
14068 struct GeneratedVisitor;
14069
14070 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14071 type Value = GeneratedField;
14072
14073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14074 write!(formatter, "expected one of: {:?}", &FIELDS)
14075 }
14076
14077 #[allow(unused_variables)]
14078 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14079 where
14080 E: serde::de::Error,
14081 {
14082 match value {
14083 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
14084 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
14085 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14086 }
14087 }
14088 }
14089 deserializer.deserialize_identifier(GeneratedVisitor)
14090 }
14091 }
14092 struct GeneratedVisitor;
14093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14094 type Value = StateTableInfoDelta;
14095
14096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14097 formatter.write_str("struct hummock.StateTableInfoDelta")
14098 }
14099
14100 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
14101 where
14102 V: serde::de::MapAccess<'de>,
14103 {
14104 let mut committed_epoch__ = None;
14105 let mut compaction_group_id__ = None;
14106 while let Some(k) = map_.next_key()? {
14107 match k {
14108 GeneratedField::CommittedEpoch => {
14109 if committed_epoch__.is_some() {
14110 return Err(serde::de::Error::duplicate_field("committedEpoch"));
14111 }
14112 committed_epoch__ =
14113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14114 ;
14115 }
14116 GeneratedField::CompactionGroupId => {
14117 if compaction_group_id__.is_some() {
14118 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14119 }
14120 compaction_group_id__ =
14121 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14122 ;
14123 }
14124 }
14125 }
14126 Ok(StateTableInfoDelta {
14127 committed_epoch: committed_epoch__.unwrap_or_default(),
14128 compaction_group_id: compaction_group_id__.unwrap_or_default(),
14129 })
14130 }
14131 }
14132 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
14133 }
14134}
14135impl serde::Serialize for SubscribeCompactionEventRequest {
14136 #[allow(deprecated)]
14137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14138 where
14139 S: serde::Serializer,
14140 {
14141 use serde::ser::SerializeStruct;
14142 let mut len = 0;
14143 if self.create_at != 0 {
14144 len += 1;
14145 }
14146 if self.event.is_some() {
14147 len += 1;
14148 }
14149 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
14150 if self.create_at != 0 {
14151 #[allow(clippy::needless_borrow)]
14152 #[allow(clippy::needless_borrows_for_generic_args)]
14153 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14154 }
14155 if let Some(v) = self.event.as_ref() {
14156 match v {
14157 subscribe_compaction_event_request::Event::Register(v) => {
14158 struct_ser.serialize_field("register", v)?;
14159 }
14160 subscribe_compaction_event_request::Event::PullTask(v) => {
14161 struct_ser.serialize_field("pullTask", v)?;
14162 }
14163 subscribe_compaction_event_request::Event::ReportTask(v) => {
14164 struct_ser.serialize_field("reportTask", v)?;
14165 }
14166 subscribe_compaction_event_request::Event::HeartBeat(v) => {
14167 struct_ser.serialize_field("heartBeat", v)?;
14168 }
14169 }
14170 }
14171 struct_ser.end()
14172 }
14173}
14174impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
14175 #[allow(deprecated)]
14176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14177 where
14178 D: serde::Deserializer<'de>,
14179 {
14180 const FIELDS: &[&str] = &[
14181 "create_at",
14182 "createAt",
14183 "register",
14184 "pull_task",
14185 "pullTask",
14186 "report_task",
14187 "reportTask",
14188 "heart_beat",
14189 "heartBeat",
14190 ];
14191
14192 #[allow(clippy::enum_variant_names)]
14193 enum GeneratedField {
14194 CreateAt,
14195 Register,
14196 PullTask,
14197 ReportTask,
14198 HeartBeat,
14199 }
14200 impl<'de> serde::Deserialize<'de> for GeneratedField {
14201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14202 where
14203 D: serde::Deserializer<'de>,
14204 {
14205 struct GeneratedVisitor;
14206
14207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14208 type Value = GeneratedField;
14209
14210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14211 write!(formatter, "expected one of: {:?}", &FIELDS)
14212 }
14213
14214 #[allow(unused_variables)]
14215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14216 where
14217 E: serde::de::Error,
14218 {
14219 match value {
14220 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14221 "register" => Ok(GeneratedField::Register),
14222 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
14223 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
14224 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
14225 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14226 }
14227 }
14228 }
14229 deserializer.deserialize_identifier(GeneratedVisitor)
14230 }
14231 }
14232 struct GeneratedVisitor;
14233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14234 type Value = SubscribeCompactionEventRequest;
14235
14236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14237 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
14238 }
14239
14240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
14241 where
14242 V: serde::de::MapAccess<'de>,
14243 {
14244 let mut create_at__ = None;
14245 let mut event__ = None;
14246 while let Some(k) = map_.next_key()? {
14247 match k {
14248 GeneratedField::CreateAt => {
14249 if create_at__.is_some() {
14250 return Err(serde::de::Error::duplicate_field("createAt"));
14251 }
14252 create_at__ =
14253 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14254 ;
14255 }
14256 GeneratedField::Register => {
14257 if event__.is_some() {
14258 return Err(serde::de::Error::duplicate_field("register"));
14259 }
14260 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
14261;
14262 }
14263 GeneratedField::PullTask => {
14264 if event__.is_some() {
14265 return Err(serde::de::Error::duplicate_field("pullTask"));
14266 }
14267 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
14268;
14269 }
14270 GeneratedField::ReportTask => {
14271 if event__.is_some() {
14272 return Err(serde::de::Error::duplicate_field("reportTask"));
14273 }
14274 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
14275;
14276 }
14277 GeneratedField::HeartBeat => {
14278 if event__.is_some() {
14279 return Err(serde::de::Error::duplicate_field("heartBeat"));
14280 }
14281 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
14282;
14283 }
14284 }
14285 }
14286 Ok(SubscribeCompactionEventRequest {
14287 create_at: create_at__.unwrap_or_default(),
14288 event: event__,
14289 })
14290 }
14291 }
14292 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
14293 }
14294}
14295impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
14296 #[allow(deprecated)]
14297 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14298 where
14299 S: serde::Serializer,
14300 {
14301 use serde::ser::SerializeStruct;
14302 let mut len = 0;
14303 if !self.progress.is_empty() {
14304 len += 1;
14305 }
14306 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
14307 if !self.progress.is_empty() {
14308 struct_ser.serialize_field("progress", &self.progress)?;
14309 }
14310 struct_ser.end()
14311 }
14312}
14313impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
14314 #[allow(deprecated)]
14315 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14316 where
14317 D: serde::Deserializer<'de>,
14318 {
14319 const FIELDS: &[&str] = &[
14320 "progress",
14321 ];
14322
14323 #[allow(clippy::enum_variant_names)]
14324 enum GeneratedField {
14325 Progress,
14326 }
14327 impl<'de> serde::Deserialize<'de> for GeneratedField {
14328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14329 where
14330 D: serde::Deserializer<'de>,
14331 {
14332 struct GeneratedVisitor;
14333
14334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14335 type Value = GeneratedField;
14336
14337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14338 write!(formatter, "expected one of: {:?}", &FIELDS)
14339 }
14340
14341 #[allow(unused_variables)]
14342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14343 where
14344 E: serde::de::Error,
14345 {
14346 match value {
14347 "progress" => Ok(GeneratedField::Progress),
14348 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14349 }
14350 }
14351 }
14352 deserializer.deserialize_identifier(GeneratedVisitor)
14353 }
14354 }
14355 struct GeneratedVisitor;
14356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14357 type Value = subscribe_compaction_event_request::HeartBeat;
14358
14359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14360 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
14361 }
14362
14363 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
14364 where
14365 V: serde::de::MapAccess<'de>,
14366 {
14367 let mut progress__ = None;
14368 while let Some(k) = map_.next_key()? {
14369 match k {
14370 GeneratedField::Progress => {
14371 if progress__.is_some() {
14372 return Err(serde::de::Error::duplicate_field("progress"));
14373 }
14374 progress__ = Some(map_.next_value()?);
14375 }
14376 }
14377 }
14378 Ok(subscribe_compaction_event_request::HeartBeat {
14379 progress: progress__.unwrap_or_default(),
14380 })
14381 }
14382 }
14383 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
14384 }
14385}
14386impl serde::Serialize for subscribe_compaction_event_request::PullTask {
14387 #[allow(deprecated)]
14388 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14389 where
14390 S: serde::Serializer,
14391 {
14392 use serde::ser::SerializeStruct;
14393 let mut len = 0;
14394 if self.pull_task_count != 0 {
14395 len += 1;
14396 }
14397 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
14398 if self.pull_task_count != 0 {
14399 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
14400 }
14401 struct_ser.end()
14402 }
14403}
14404impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
14405 #[allow(deprecated)]
14406 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14407 where
14408 D: serde::Deserializer<'de>,
14409 {
14410 const FIELDS: &[&str] = &[
14411 "pull_task_count",
14412 "pullTaskCount",
14413 ];
14414
14415 #[allow(clippy::enum_variant_names)]
14416 enum GeneratedField {
14417 PullTaskCount,
14418 }
14419 impl<'de> serde::Deserialize<'de> for GeneratedField {
14420 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14421 where
14422 D: serde::Deserializer<'de>,
14423 {
14424 struct GeneratedVisitor;
14425
14426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14427 type Value = GeneratedField;
14428
14429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14430 write!(formatter, "expected one of: {:?}", &FIELDS)
14431 }
14432
14433 #[allow(unused_variables)]
14434 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14435 where
14436 E: serde::de::Error,
14437 {
14438 match value {
14439 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
14440 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14441 }
14442 }
14443 }
14444 deserializer.deserialize_identifier(GeneratedVisitor)
14445 }
14446 }
14447 struct GeneratedVisitor;
14448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14449 type Value = subscribe_compaction_event_request::PullTask;
14450
14451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14452 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
14453 }
14454
14455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
14456 where
14457 V: serde::de::MapAccess<'de>,
14458 {
14459 let mut pull_task_count__ = None;
14460 while let Some(k) = map_.next_key()? {
14461 match k {
14462 GeneratedField::PullTaskCount => {
14463 if pull_task_count__.is_some() {
14464 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
14465 }
14466 pull_task_count__ =
14467 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14468 ;
14469 }
14470 }
14471 }
14472 Ok(subscribe_compaction_event_request::PullTask {
14473 pull_task_count: pull_task_count__.unwrap_or_default(),
14474 })
14475 }
14476 }
14477 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
14478 }
14479}
14480impl serde::Serialize for subscribe_compaction_event_request::Register {
14481 #[allow(deprecated)]
14482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14483 where
14484 S: serde::Serializer,
14485 {
14486 use serde::ser::SerializeStruct;
14487 let mut len = 0;
14488 if self.context_id != 0 {
14489 len += 1;
14490 }
14491 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
14492 if self.context_id != 0 {
14493 struct_ser.serialize_field("contextId", &self.context_id)?;
14494 }
14495 struct_ser.end()
14496 }
14497}
14498impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
14499 #[allow(deprecated)]
14500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14501 where
14502 D: serde::Deserializer<'de>,
14503 {
14504 const FIELDS: &[&str] = &[
14505 "context_id",
14506 "contextId",
14507 ];
14508
14509 #[allow(clippy::enum_variant_names)]
14510 enum GeneratedField {
14511 ContextId,
14512 }
14513 impl<'de> serde::Deserialize<'de> for GeneratedField {
14514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14515 where
14516 D: serde::Deserializer<'de>,
14517 {
14518 struct GeneratedVisitor;
14519
14520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14521 type Value = GeneratedField;
14522
14523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14524 write!(formatter, "expected one of: {:?}", &FIELDS)
14525 }
14526
14527 #[allow(unused_variables)]
14528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14529 where
14530 E: serde::de::Error,
14531 {
14532 match value {
14533 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
14534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14535 }
14536 }
14537 }
14538 deserializer.deserialize_identifier(GeneratedVisitor)
14539 }
14540 }
14541 struct GeneratedVisitor;
14542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14543 type Value = subscribe_compaction_event_request::Register;
14544
14545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14546 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
14547 }
14548
14549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
14550 where
14551 V: serde::de::MapAccess<'de>,
14552 {
14553 let mut context_id__ = None;
14554 while let Some(k) = map_.next_key()? {
14555 match k {
14556 GeneratedField::ContextId => {
14557 if context_id__.is_some() {
14558 return Err(serde::de::Error::duplicate_field("contextId"));
14559 }
14560 context_id__ =
14561 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14562 ;
14563 }
14564 }
14565 }
14566 Ok(subscribe_compaction_event_request::Register {
14567 context_id: context_id__.unwrap_or_default(),
14568 })
14569 }
14570 }
14571 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
14572 }
14573}
14574impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
14575 #[allow(deprecated)]
14576 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14577 where
14578 S: serde::Serializer,
14579 {
14580 use serde::ser::SerializeStruct;
14581 let mut len = 0;
14582 if !self.table_stats_change.is_empty() {
14583 len += 1;
14584 }
14585 if self.task_id != 0 {
14586 len += 1;
14587 }
14588 if self.task_status != 0 {
14589 len += 1;
14590 }
14591 if !self.sorted_output_ssts.is_empty() {
14592 len += 1;
14593 }
14594 if !self.object_timestamps.is_empty() {
14595 len += 1;
14596 }
14597 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
14598 if !self.table_stats_change.is_empty() {
14599 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
14600 }
14601 if self.task_id != 0 {
14602 #[allow(clippy::needless_borrow)]
14603 #[allow(clippy::needless_borrows_for_generic_args)]
14604 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
14605 }
14606 if self.task_status != 0 {
14607 let v = compact_task::TaskStatus::try_from(self.task_status)
14608 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
14609 struct_ser.serialize_field("taskStatus", &v)?;
14610 }
14611 if !self.sorted_output_ssts.is_empty() {
14612 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
14613 }
14614 if !self.object_timestamps.is_empty() {
14615 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
14616 .map(|(k, v)| (k, v.to_string())).collect();
14617 struct_ser.serialize_field("objectTimestamps", &v)?;
14618 }
14619 struct_ser.end()
14620 }
14621}
14622impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
14623 #[allow(deprecated)]
14624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14625 where
14626 D: serde::Deserializer<'de>,
14627 {
14628 const FIELDS: &[&str] = &[
14629 "table_stats_change",
14630 "tableStatsChange",
14631 "task_id",
14632 "taskId",
14633 "task_status",
14634 "taskStatus",
14635 "sorted_output_ssts",
14636 "sortedOutputSsts",
14637 "object_timestamps",
14638 "objectTimestamps",
14639 ];
14640
14641 #[allow(clippy::enum_variant_names)]
14642 enum GeneratedField {
14643 TableStatsChange,
14644 TaskId,
14645 TaskStatus,
14646 SortedOutputSsts,
14647 ObjectTimestamps,
14648 }
14649 impl<'de> serde::Deserialize<'de> for GeneratedField {
14650 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14651 where
14652 D: serde::Deserializer<'de>,
14653 {
14654 struct GeneratedVisitor;
14655
14656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14657 type Value = GeneratedField;
14658
14659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14660 write!(formatter, "expected one of: {:?}", &FIELDS)
14661 }
14662
14663 #[allow(unused_variables)]
14664 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14665 where
14666 E: serde::de::Error,
14667 {
14668 match value {
14669 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
14670 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
14671 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
14672 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
14673 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
14674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14675 }
14676 }
14677 }
14678 deserializer.deserialize_identifier(GeneratedVisitor)
14679 }
14680 }
14681 struct GeneratedVisitor;
14682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14683 type Value = subscribe_compaction_event_request::ReportTask;
14684
14685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14686 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
14687 }
14688
14689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
14690 where
14691 V: serde::de::MapAccess<'de>,
14692 {
14693 let mut table_stats_change__ = None;
14694 let mut task_id__ = None;
14695 let mut task_status__ = None;
14696 let mut sorted_output_ssts__ = None;
14697 let mut object_timestamps__ = None;
14698 while let Some(k) = map_.next_key()? {
14699 match k {
14700 GeneratedField::TableStatsChange => {
14701 if table_stats_change__.is_some() {
14702 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
14703 }
14704 table_stats_change__ = Some(
14705 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14706 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14707 );
14708 }
14709 GeneratedField::TaskId => {
14710 if task_id__.is_some() {
14711 return Err(serde::de::Error::duplicate_field("taskId"));
14712 }
14713 task_id__ =
14714 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14715 ;
14716 }
14717 GeneratedField::TaskStatus => {
14718 if task_status__.is_some() {
14719 return Err(serde::de::Error::duplicate_field("taskStatus"));
14720 }
14721 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
14722 }
14723 GeneratedField::SortedOutputSsts => {
14724 if sorted_output_ssts__.is_some() {
14725 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
14726 }
14727 sorted_output_ssts__ = Some(map_.next_value()?);
14728 }
14729 GeneratedField::ObjectTimestamps => {
14730 if object_timestamps__.is_some() {
14731 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
14732 }
14733 object_timestamps__ = Some(
14734 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14735 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
14736 );
14737 }
14738 }
14739 }
14740 Ok(subscribe_compaction_event_request::ReportTask {
14741 table_stats_change: table_stats_change__.unwrap_or_default(),
14742 task_id: task_id__.unwrap_or_default(),
14743 task_status: task_status__.unwrap_or_default(),
14744 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
14745 object_timestamps: object_timestamps__.unwrap_or_default(),
14746 })
14747 }
14748 }
14749 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
14750 }
14751}
14752impl serde::Serialize for SubscribeCompactionEventResponse {
14753 #[allow(deprecated)]
14754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14755 where
14756 S: serde::Serializer,
14757 {
14758 use serde::ser::SerializeStruct;
14759 let mut len = 0;
14760 if self.create_at != 0 {
14761 len += 1;
14762 }
14763 if self.event.is_some() {
14764 len += 1;
14765 }
14766 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
14767 if self.create_at != 0 {
14768 #[allow(clippy::needless_borrow)]
14769 #[allow(clippy::needless_borrows_for_generic_args)]
14770 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14771 }
14772 if let Some(v) = self.event.as_ref() {
14773 match v {
14774 subscribe_compaction_event_response::Event::CompactTask(v) => {
14775 struct_ser.serialize_field("compactTask", v)?;
14776 }
14777 subscribe_compaction_event_response::Event::VacuumTask(v) => {
14778 struct_ser.serialize_field("vacuumTask", v)?;
14779 }
14780 subscribe_compaction_event_response::Event::FullScanTask(v) => {
14781 struct_ser.serialize_field("fullScanTask", v)?;
14782 }
14783 subscribe_compaction_event_response::Event::ValidationTask(v) => {
14784 struct_ser.serialize_field("validationTask", v)?;
14785 }
14786 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
14787 struct_ser.serialize_field("cancelCompactTask", v)?;
14788 }
14789 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
14790 struct_ser.serialize_field("pullTaskAck", v)?;
14791 }
14792 }
14793 }
14794 struct_ser.end()
14795 }
14796}
14797impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
14798 #[allow(deprecated)]
14799 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14800 where
14801 D: serde::Deserializer<'de>,
14802 {
14803 const FIELDS: &[&str] = &[
14804 "create_at",
14805 "createAt",
14806 "compact_task",
14807 "compactTask",
14808 "vacuum_task",
14809 "vacuumTask",
14810 "full_scan_task",
14811 "fullScanTask",
14812 "validation_task",
14813 "validationTask",
14814 "cancel_compact_task",
14815 "cancelCompactTask",
14816 "pull_task_ack",
14817 "pullTaskAck",
14818 ];
14819
14820 #[allow(clippy::enum_variant_names)]
14821 enum GeneratedField {
14822 CreateAt,
14823 CompactTask,
14824 VacuumTask,
14825 FullScanTask,
14826 ValidationTask,
14827 CancelCompactTask,
14828 PullTaskAck,
14829 }
14830 impl<'de> serde::Deserialize<'de> for GeneratedField {
14831 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14832 where
14833 D: serde::Deserializer<'de>,
14834 {
14835 struct GeneratedVisitor;
14836
14837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14838 type Value = GeneratedField;
14839
14840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14841 write!(formatter, "expected one of: {:?}", &FIELDS)
14842 }
14843
14844 #[allow(unused_variables)]
14845 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14846 where
14847 E: serde::de::Error,
14848 {
14849 match value {
14850 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14851 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
14852 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
14853 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
14854 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
14855 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
14856 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
14857 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14858 }
14859 }
14860 }
14861 deserializer.deserialize_identifier(GeneratedVisitor)
14862 }
14863 }
14864 struct GeneratedVisitor;
14865 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14866 type Value = SubscribeCompactionEventResponse;
14867
14868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14869 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
14870 }
14871
14872 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
14873 where
14874 V: serde::de::MapAccess<'de>,
14875 {
14876 let mut create_at__ = None;
14877 let mut event__ = None;
14878 while let Some(k) = map_.next_key()? {
14879 match k {
14880 GeneratedField::CreateAt => {
14881 if create_at__.is_some() {
14882 return Err(serde::de::Error::duplicate_field("createAt"));
14883 }
14884 create_at__ =
14885 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14886 ;
14887 }
14888 GeneratedField::CompactTask => {
14889 if event__.is_some() {
14890 return Err(serde::de::Error::duplicate_field("compactTask"));
14891 }
14892 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
14893;
14894 }
14895 GeneratedField::VacuumTask => {
14896 if event__.is_some() {
14897 return Err(serde::de::Error::duplicate_field("vacuumTask"));
14898 }
14899 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
14900;
14901 }
14902 GeneratedField::FullScanTask => {
14903 if event__.is_some() {
14904 return Err(serde::de::Error::duplicate_field("fullScanTask"));
14905 }
14906 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
14907;
14908 }
14909 GeneratedField::ValidationTask => {
14910 if event__.is_some() {
14911 return Err(serde::de::Error::duplicate_field("validationTask"));
14912 }
14913 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
14914;
14915 }
14916 GeneratedField::CancelCompactTask => {
14917 if event__.is_some() {
14918 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
14919 }
14920 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
14921;
14922 }
14923 GeneratedField::PullTaskAck => {
14924 if event__.is_some() {
14925 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
14926 }
14927 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
14928;
14929 }
14930 }
14931 }
14932 Ok(SubscribeCompactionEventResponse {
14933 create_at: create_at__.unwrap_or_default(),
14934 event: event__,
14935 })
14936 }
14937 }
14938 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
14939 }
14940}
14941impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
14942 #[allow(deprecated)]
14943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14944 where
14945 S: serde::Serializer,
14946 {
14947 use serde::ser::SerializeStruct;
14948 let len = 0;
14949 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
14950 struct_ser.end()
14951 }
14952}
14953impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
14954 #[allow(deprecated)]
14955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14956 where
14957 D: serde::Deserializer<'de>,
14958 {
14959 const FIELDS: &[&str] = &[
14960 ];
14961
14962 #[allow(clippy::enum_variant_names)]
14963 enum GeneratedField {
14964 }
14965 impl<'de> serde::Deserialize<'de> for GeneratedField {
14966 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14967 where
14968 D: serde::Deserializer<'de>,
14969 {
14970 struct GeneratedVisitor;
14971
14972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14973 type Value = GeneratedField;
14974
14975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14976 write!(formatter, "expected one of: {:?}", &FIELDS)
14977 }
14978
14979 #[allow(unused_variables)]
14980 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14981 where
14982 E: serde::de::Error,
14983 {
14984 Err(serde::de::Error::unknown_field(value, FIELDS))
14985 }
14986 }
14987 deserializer.deserialize_identifier(GeneratedVisitor)
14988 }
14989 }
14990 struct GeneratedVisitor;
14991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14992 type Value = subscribe_compaction_event_response::PullTaskAck;
14993
14994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14995 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
14996 }
14997
14998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
14999 where
15000 V: serde::de::MapAccess<'de>,
15001 {
15002 while map_.next_key::<GeneratedField>()?.is_some() {
15003 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15004 }
15005 Ok(subscribe_compaction_event_response::PullTaskAck {
15006 })
15007 }
15008 }
15009 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
15010 }
15011}
15012impl serde::Serialize for TableChangeLog {
15013 #[allow(deprecated)]
15014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15015 where
15016 S: serde::Serializer,
15017 {
15018 use serde::ser::SerializeStruct;
15019 let mut len = 0;
15020 if !self.change_logs.is_empty() {
15021 len += 1;
15022 }
15023 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
15024 if !self.change_logs.is_empty() {
15025 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
15026 }
15027 struct_ser.end()
15028 }
15029}
15030impl<'de> serde::Deserialize<'de> for TableChangeLog {
15031 #[allow(deprecated)]
15032 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15033 where
15034 D: serde::Deserializer<'de>,
15035 {
15036 const FIELDS: &[&str] = &[
15037 "change_logs",
15038 "changeLogs",
15039 ];
15040
15041 #[allow(clippy::enum_variant_names)]
15042 enum GeneratedField {
15043 ChangeLogs,
15044 }
15045 impl<'de> serde::Deserialize<'de> for GeneratedField {
15046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15047 where
15048 D: serde::Deserializer<'de>,
15049 {
15050 struct GeneratedVisitor;
15051
15052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15053 type Value = GeneratedField;
15054
15055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15056 write!(formatter, "expected one of: {:?}", &FIELDS)
15057 }
15058
15059 #[allow(unused_variables)]
15060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15061 where
15062 E: serde::de::Error,
15063 {
15064 match value {
15065 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
15066 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15067 }
15068 }
15069 }
15070 deserializer.deserialize_identifier(GeneratedVisitor)
15071 }
15072 }
15073 struct GeneratedVisitor;
15074 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15075 type Value = TableChangeLog;
15076
15077 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15078 formatter.write_str("struct hummock.TableChangeLog")
15079 }
15080
15081 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
15082 where
15083 V: serde::de::MapAccess<'de>,
15084 {
15085 let mut change_logs__ = None;
15086 while let Some(k) = map_.next_key()? {
15087 match k {
15088 GeneratedField::ChangeLogs => {
15089 if change_logs__.is_some() {
15090 return Err(serde::de::Error::duplicate_field("changeLogs"));
15091 }
15092 change_logs__ = Some(map_.next_value()?);
15093 }
15094 }
15095 }
15096 Ok(TableChangeLog {
15097 change_logs: change_logs__.unwrap_or_default(),
15098 })
15099 }
15100 }
15101 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
15102 }
15103}
15104impl serde::Serialize for TableOption {
15105 #[allow(deprecated)]
15106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15107 where
15108 S: serde::Serializer,
15109 {
15110 use serde::ser::SerializeStruct;
15111 let mut len = 0;
15112 if self.retention_seconds.is_some() {
15113 len += 1;
15114 }
15115 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
15116 if let Some(v) = self.retention_seconds.as_ref() {
15117 struct_ser.serialize_field("retentionSeconds", v)?;
15118 }
15119 struct_ser.end()
15120 }
15121}
15122impl<'de> serde::Deserialize<'de> for TableOption {
15123 #[allow(deprecated)]
15124 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15125 where
15126 D: serde::Deserializer<'de>,
15127 {
15128 const FIELDS: &[&str] = &[
15129 "retention_seconds",
15130 "retentionSeconds",
15131 ];
15132
15133 #[allow(clippy::enum_variant_names)]
15134 enum GeneratedField {
15135 RetentionSeconds,
15136 }
15137 impl<'de> serde::Deserialize<'de> for GeneratedField {
15138 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15139 where
15140 D: serde::Deserializer<'de>,
15141 {
15142 struct GeneratedVisitor;
15143
15144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15145 type Value = GeneratedField;
15146
15147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15148 write!(formatter, "expected one of: {:?}", &FIELDS)
15149 }
15150
15151 #[allow(unused_variables)]
15152 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15153 where
15154 E: serde::de::Error,
15155 {
15156 match value {
15157 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
15158 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15159 }
15160 }
15161 }
15162 deserializer.deserialize_identifier(GeneratedVisitor)
15163 }
15164 }
15165 struct GeneratedVisitor;
15166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15167 type Value = TableOption;
15168
15169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15170 formatter.write_str("struct hummock.TableOption")
15171 }
15172
15173 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
15174 where
15175 V: serde::de::MapAccess<'de>,
15176 {
15177 let mut retention_seconds__ = None;
15178 while let Some(k) = map_.next_key()? {
15179 match k {
15180 GeneratedField::RetentionSeconds => {
15181 if retention_seconds__.is_some() {
15182 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
15183 }
15184 retention_seconds__ =
15185 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15186 ;
15187 }
15188 }
15189 }
15190 Ok(TableOption {
15191 retention_seconds: retention_seconds__,
15192 })
15193 }
15194 }
15195 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
15196 }
15197}
15198impl serde::Serialize for TableSchema {
15199 #[allow(deprecated)]
15200 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15201 where
15202 S: serde::Serializer,
15203 {
15204 use serde::ser::SerializeStruct;
15205 let mut len = 0;
15206 if !self.column_ids.is_empty() {
15207 len += 1;
15208 }
15209 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
15210 if !self.column_ids.is_empty() {
15211 struct_ser.serialize_field("columnIds", &self.column_ids)?;
15212 }
15213 struct_ser.end()
15214 }
15215}
15216impl<'de> serde::Deserialize<'de> for TableSchema {
15217 #[allow(deprecated)]
15218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15219 where
15220 D: serde::Deserializer<'de>,
15221 {
15222 const FIELDS: &[&str] = &[
15223 "column_ids",
15224 "columnIds",
15225 ];
15226
15227 #[allow(clippy::enum_variant_names)]
15228 enum GeneratedField {
15229 ColumnIds,
15230 }
15231 impl<'de> serde::Deserialize<'de> for GeneratedField {
15232 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15233 where
15234 D: serde::Deserializer<'de>,
15235 {
15236 struct GeneratedVisitor;
15237
15238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15239 type Value = GeneratedField;
15240
15241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15242 write!(formatter, "expected one of: {:?}", &FIELDS)
15243 }
15244
15245 #[allow(unused_variables)]
15246 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15247 where
15248 E: serde::de::Error,
15249 {
15250 match value {
15251 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
15252 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15253 }
15254 }
15255 }
15256 deserializer.deserialize_identifier(GeneratedVisitor)
15257 }
15258 }
15259 struct GeneratedVisitor;
15260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15261 type Value = TableSchema;
15262
15263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15264 formatter.write_str("struct hummock.TableSchema")
15265 }
15266
15267 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
15268 where
15269 V: serde::de::MapAccess<'de>,
15270 {
15271 let mut column_ids__ = None;
15272 while let Some(k) = map_.next_key()? {
15273 match k {
15274 GeneratedField::ColumnIds => {
15275 if column_ids__.is_some() {
15276 return Err(serde::de::Error::duplicate_field("columnIds"));
15277 }
15278 column_ids__ =
15279 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15280 .into_iter().map(|x| x.0).collect())
15281 ;
15282 }
15283 }
15284 }
15285 Ok(TableSchema {
15286 column_ids: column_ids__.unwrap_or_default(),
15287 })
15288 }
15289 }
15290 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
15291 }
15292}
15293impl serde::Serialize for TableStats {
15294 #[allow(deprecated)]
15295 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15296 where
15297 S: serde::Serializer,
15298 {
15299 use serde::ser::SerializeStruct;
15300 let mut len = 0;
15301 if self.total_key_size != 0 {
15302 len += 1;
15303 }
15304 if self.total_value_size != 0 {
15305 len += 1;
15306 }
15307 if self.total_key_count != 0 {
15308 len += 1;
15309 }
15310 if self.total_compressed_size != 0 {
15311 len += 1;
15312 }
15313 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
15314 if self.total_key_size != 0 {
15315 #[allow(clippy::needless_borrow)]
15316 #[allow(clippy::needless_borrows_for_generic_args)]
15317 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
15318 }
15319 if self.total_value_size != 0 {
15320 #[allow(clippy::needless_borrow)]
15321 #[allow(clippy::needless_borrows_for_generic_args)]
15322 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
15323 }
15324 if self.total_key_count != 0 {
15325 #[allow(clippy::needless_borrow)]
15326 #[allow(clippy::needless_borrows_for_generic_args)]
15327 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
15328 }
15329 if self.total_compressed_size != 0 {
15330 #[allow(clippy::needless_borrow)]
15331 #[allow(clippy::needless_borrows_for_generic_args)]
15332 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
15333 }
15334 struct_ser.end()
15335 }
15336}
15337impl<'de> serde::Deserialize<'de> for TableStats {
15338 #[allow(deprecated)]
15339 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15340 where
15341 D: serde::Deserializer<'de>,
15342 {
15343 const FIELDS: &[&str] = &[
15344 "total_key_size",
15345 "totalKeySize",
15346 "total_value_size",
15347 "totalValueSize",
15348 "total_key_count",
15349 "totalKeyCount",
15350 "total_compressed_size",
15351 "totalCompressedSize",
15352 ];
15353
15354 #[allow(clippy::enum_variant_names)]
15355 enum GeneratedField {
15356 TotalKeySize,
15357 TotalValueSize,
15358 TotalKeyCount,
15359 TotalCompressedSize,
15360 }
15361 impl<'de> serde::Deserialize<'de> for GeneratedField {
15362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15363 where
15364 D: serde::Deserializer<'de>,
15365 {
15366 struct GeneratedVisitor;
15367
15368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15369 type Value = GeneratedField;
15370
15371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15372 write!(formatter, "expected one of: {:?}", &FIELDS)
15373 }
15374
15375 #[allow(unused_variables)]
15376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15377 where
15378 E: serde::de::Error,
15379 {
15380 match value {
15381 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
15382 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
15383 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
15384 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
15385 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15386 }
15387 }
15388 }
15389 deserializer.deserialize_identifier(GeneratedVisitor)
15390 }
15391 }
15392 struct GeneratedVisitor;
15393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15394 type Value = TableStats;
15395
15396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15397 formatter.write_str("struct hummock.TableStats")
15398 }
15399
15400 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
15401 where
15402 V: serde::de::MapAccess<'de>,
15403 {
15404 let mut total_key_size__ = None;
15405 let mut total_value_size__ = None;
15406 let mut total_key_count__ = None;
15407 let mut total_compressed_size__ = None;
15408 while let Some(k) = map_.next_key()? {
15409 match k {
15410 GeneratedField::TotalKeySize => {
15411 if total_key_size__.is_some() {
15412 return Err(serde::de::Error::duplicate_field("totalKeySize"));
15413 }
15414 total_key_size__ =
15415 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15416 ;
15417 }
15418 GeneratedField::TotalValueSize => {
15419 if total_value_size__.is_some() {
15420 return Err(serde::de::Error::duplicate_field("totalValueSize"));
15421 }
15422 total_value_size__ =
15423 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15424 ;
15425 }
15426 GeneratedField::TotalKeyCount => {
15427 if total_key_count__.is_some() {
15428 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
15429 }
15430 total_key_count__ =
15431 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15432 ;
15433 }
15434 GeneratedField::TotalCompressedSize => {
15435 if total_compressed_size__.is_some() {
15436 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
15437 }
15438 total_compressed_size__ =
15439 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15440 ;
15441 }
15442 }
15443 }
15444 Ok(TableStats {
15445 total_key_size: total_key_size__.unwrap_or_default(),
15446 total_value_size: total_value_size__.unwrap_or_default(),
15447 total_key_count: total_key_count__.unwrap_or_default(),
15448 total_compressed_size: total_compressed_size__.unwrap_or_default(),
15449 })
15450 }
15451 }
15452 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
15453 }
15454}
15455impl serde::Serialize for TableWatermarks {
15456 #[allow(deprecated)]
15457 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15458 where
15459 S: serde::Serializer,
15460 {
15461 use serde::ser::SerializeStruct;
15462 let mut len = 0;
15463 if !self.epoch_watermarks.is_empty() {
15464 len += 1;
15465 }
15466 if self.is_ascending {
15467 len += 1;
15468 }
15469 if self.is_non_pk_prefix {
15470 len += 1;
15471 }
15472 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
15473 if !self.epoch_watermarks.is_empty() {
15474 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
15475 }
15476 if self.is_ascending {
15477 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
15478 }
15479 if self.is_non_pk_prefix {
15480 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
15481 }
15482 struct_ser.end()
15483 }
15484}
15485impl<'de> serde::Deserialize<'de> for TableWatermarks {
15486 #[allow(deprecated)]
15487 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15488 where
15489 D: serde::Deserializer<'de>,
15490 {
15491 const FIELDS: &[&str] = &[
15492 "epoch_watermarks",
15493 "epochWatermarks",
15494 "is_ascending",
15495 "isAscending",
15496 "is_non_pk_prefix",
15497 "isNonPkPrefix",
15498 ];
15499
15500 #[allow(clippy::enum_variant_names)]
15501 enum GeneratedField {
15502 EpochWatermarks,
15503 IsAscending,
15504 IsNonPkPrefix,
15505 }
15506 impl<'de> serde::Deserialize<'de> for GeneratedField {
15507 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15508 where
15509 D: serde::Deserializer<'de>,
15510 {
15511 struct GeneratedVisitor;
15512
15513 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15514 type Value = GeneratedField;
15515
15516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15517 write!(formatter, "expected one of: {:?}", &FIELDS)
15518 }
15519
15520 #[allow(unused_variables)]
15521 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15522 where
15523 E: serde::de::Error,
15524 {
15525 match value {
15526 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
15527 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
15528 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
15529 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15530 }
15531 }
15532 }
15533 deserializer.deserialize_identifier(GeneratedVisitor)
15534 }
15535 }
15536 struct GeneratedVisitor;
15537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15538 type Value = TableWatermarks;
15539
15540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15541 formatter.write_str("struct hummock.TableWatermarks")
15542 }
15543
15544 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
15545 where
15546 V: serde::de::MapAccess<'de>,
15547 {
15548 let mut epoch_watermarks__ = None;
15549 let mut is_ascending__ = None;
15550 let mut is_non_pk_prefix__ = None;
15551 while let Some(k) = map_.next_key()? {
15552 match k {
15553 GeneratedField::EpochWatermarks => {
15554 if epoch_watermarks__.is_some() {
15555 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
15556 }
15557 epoch_watermarks__ = Some(map_.next_value()?);
15558 }
15559 GeneratedField::IsAscending => {
15560 if is_ascending__.is_some() {
15561 return Err(serde::de::Error::duplicate_field("isAscending"));
15562 }
15563 is_ascending__ = Some(map_.next_value()?);
15564 }
15565 GeneratedField::IsNonPkPrefix => {
15566 if is_non_pk_prefix__.is_some() {
15567 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
15568 }
15569 is_non_pk_prefix__ = Some(map_.next_value()?);
15570 }
15571 }
15572 }
15573 Ok(TableWatermarks {
15574 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
15575 is_ascending: is_ascending__.unwrap_or_default(),
15576 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
15577 })
15578 }
15579 }
15580 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
15581 }
15582}
15583impl serde::Serialize for table_watermarks::EpochNewWatermarks {
15584 #[allow(deprecated)]
15585 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15586 where
15587 S: serde::Serializer,
15588 {
15589 use serde::ser::SerializeStruct;
15590 let mut len = 0;
15591 if !self.watermarks.is_empty() {
15592 len += 1;
15593 }
15594 if self.epoch != 0 {
15595 len += 1;
15596 }
15597 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
15598 if !self.watermarks.is_empty() {
15599 struct_ser.serialize_field("watermarks", &self.watermarks)?;
15600 }
15601 if self.epoch != 0 {
15602 #[allow(clippy::needless_borrow)]
15603 #[allow(clippy::needless_borrows_for_generic_args)]
15604 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
15605 }
15606 struct_ser.end()
15607 }
15608}
15609impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
15610 #[allow(deprecated)]
15611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15612 where
15613 D: serde::Deserializer<'de>,
15614 {
15615 const FIELDS: &[&str] = &[
15616 "watermarks",
15617 "epoch",
15618 ];
15619
15620 #[allow(clippy::enum_variant_names)]
15621 enum GeneratedField {
15622 Watermarks,
15623 Epoch,
15624 }
15625 impl<'de> serde::Deserialize<'de> for GeneratedField {
15626 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15627 where
15628 D: serde::Deserializer<'de>,
15629 {
15630 struct GeneratedVisitor;
15631
15632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15633 type Value = GeneratedField;
15634
15635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15636 write!(formatter, "expected one of: {:?}", &FIELDS)
15637 }
15638
15639 #[allow(unused_variables)]
15640 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15641 where
15642 E: serde::de::Error,
15643 {
15644 match value {
15645 "watermarks" => Ok(GeneratedField::Watermarks),
15646 "epoch" => Ok(GeneratedField::Epoch),
15647 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15648 }
15649 }
15650 }
15651 deserializer.deserialize_identifier(GeneratedVisitor)
15652 }
15653 }
15654 struct GeneratedVisitor;
15655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15656 type Value = table_watermarks::EpochNewWatermarks;
15657
15658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15659 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
15660 }
15661
15662 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
15663 where
15664 V: serde::de::MapAccess<'de>,
15665 {
15666 let mut watermarks__ = None;
15667 let mut epoch__ = None;
15668 while let Some(k) = map_.next_key()? {
15669 match k {
15670 GeneratedField::Watermarks => {
15671 if watermarks__.is_some() {
15672 return Err(serde::de::Error::duplicate_field("watermarks"));
15673 }
15674 watermarks__ = Some(map_.next_value()?);
15675 }
15676 GeneratedField::Epoch => {
15677 if epoch__.is_some() {
15678 return Err(serde::de::Error::duplicate_field("epoch"));
15679 }
15680 epoch__ =
15681 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15682 ;
15683 }
15684 }
15685 }
15686 Ok(table_watermarks::EpochNewWatermarks {
15687 watermarks: watermarks__.unwrap_or_default(),
15688 epoch: epoch__.unwrap_or_default(),
15689 })
15690 }
15691 }
15692 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
15693 }
15694}
15695impl serde::Serialize for TriggerCompactionDeterministicRequest {
15696 #[allow(deprecated)]
15697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15698 where
15699 S: serde::Serializer,
15700 {
15701 use serde::ser::SerializeStruct;
15702 let mut len = 0;
15703 if self.version_id != 0 {
15704 len += 1;
15705 }
15706 if !self.compaction_groups.is_empty() {
15707 len += 1;
15708 }
15709 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
15710 if self.version_id != 0 {
15711 #[allow(clippy::needless_borrow)]
15712 #[allow(clippy::needless_borrows_for_generic_args)]
15713 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
15714 }
15715 if !self.compaction_groups.is_empty() {
15716 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15717 }
15718 struct_ser.end()
15719 }
15720}
15721impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
15722 #[allow(deprecated)]
15723 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15724 where
15725 D: serde::Deserializer<'de>,
15726 {
15727 const FIELDS: &[&str] = &[
15728 "version_id",
15729 "versionId",
15730 "compaction_groups",
15731 "compactionGroups",
15732 ];
15733
15734 #[allow(clippy::enum_variant_names)]
15735 enum GeneratedField {
15736 VersionId,
15737 CompactionGroups,
15738 }
15739 impl<'de> serde::Deserialize<'de> for GeneratedField {
15740 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15741 where
15742 D: serde::Deserializer<'de>,
15743 {
15744 struct GeneratedVisitor;
15745
15746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15747 type Value = GeneratedField;
15748
15749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15750 write!(formatter, "expected one of: {:?}", &FIELDS)
15751 }
15752
15753 #[allow(unused_variables)]
15754 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15755 where
15756 E: serde::de::Error,
15757 {
15758 match value {
15759 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
15760 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
15761 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15762 }
15763 }
15764 }
15765 deserializer.deserialize_identifier(GeneratedVisitor)
15766 }
15767 }
15768 struct GeneratedVisitor;
15769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15770 type Value = TriggerCompactionDeterministicRequest;
15771
15772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15773 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
15774 }
15775
15776 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
15777 where
15778 V: serde::de::MapAccess<'de>,
15779 {
15780 let mut version_id__ = None;
15781 let mut compaction_groups__ = None;
15782 while let Some(k) = map_.next_key()? {
15783 match k {
15784 GeneratedField::VersionId => {
15785 if version_id__.is_some() {
15786 return Err(serde::de::Error::duplicate_field("versionId"));
15787 }
15788 version_id__ =
15789 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15790 ;
15791 }
15792 GeneratedField::CompactionGroups => {
15793 if compaction_groups__.is_some() {
15794 return Err(serde::de::Error::duplicate_field("compactionGroups"));
15795 }
15796 compaction_groups__ =
15797 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15798 .into_iter().map(|x| x.0).collect())
15799 ;
15800 }
15801 }
15802 }
15803 Ok(TriggerCompactionDeterministicRequest {
15804 version_id: version_id__.unwrap_or_default(),
15805 compaction_groups: compaction_groups__.unwrap_or_default(),
15806 })
15807 }
15808 }
15809 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
15810 }
15811}
15812impl serde::Serialize for TriggerCompactionDeterministicResponse {
15813 #[allow(deprecated)]
15814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15815 where
15816 S: serde::Serializer,
15817 {
15818 use serde::ser::SerializeStruct;
15819 let len = 0;
15820 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
15821 struct_ser.end()
15822 }
15823}
15824impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
15825 #[allow(deprecated)]
15826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15827 where
15828 D: serde::Deserializer<'de>,
15829 {
15830 const FIELDS: &[&str] = &[
15831 ];
15832
15833 #[allow(clippy::enum_variant_names)]
15834 enum GeneratedField {
15835 }
15836 impl<'de> serde::Deserialize<'de> for GeneratedField {
15837 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15838 where
15839 D: serde::Deserializer<'de>,
15840 {
15841 struct GeneratedVisitor;
15842
15843 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15844 type Value = GeneratedField;
15845
15846 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15847 write!(formatter, "expected one of: {:?}", &FIELDS)
15848 }
15849
15850 #[allow(unused_variables)]
15851 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15852 where
15853 E: serde::de::Error,
15854 {
15855 Err(serde::de::Error::unknown_field(value, FIELDS))
15856 }
15857 }
15858 deserializer.deserialize_identifier(GeneratedVisitor)
15859 }
15860 }
15861 struct GeneratedVisitor;
15862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15863 type Value = TriggerCompactionDeterministicResponse;
15864
15865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15866 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
15867 }
15868
15869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
15870 where
15871 V: serde::de::MapAccess<'de>,
15872 {
15873 while map_.next_key::<GeneratedField>()?.is_some() {
15874 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15875 }
15876 Ok(TriggerCompactionDeterministicResponse {
15877 })
15878 }
15879 }
15880 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
15881 }
15882}
15883impl serde::Serialize for TriggerFullGcRequest {
15884 #[allow(deprecated)]
15885 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15886 where
15887 S: serde::Serializer,
15888 {
15889 use serde::ser::SerializeStruct;
15890 let mut len = 0;
15891 if self.sst_retention_time_sec != 0 {
15892 len += 1;
15893 }
15894 if self.prefix.is_some() {
15895 len += 1;
15896 }
15897 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
15898 if self.sst_retention_time_sec != 0 {
15899 #[allow(clippy::needless_borrow)]
15900 #[allow(clippy::needless_borrows_for_generic_args)]
15901 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
15902 }
15903 if let Some(v) = self.prefix.as_ref() {
15904 struct_ser.serialize_field("prefix", v)?;
15905 }
15906 struct_ser.end()
15907 }
15908}
15909impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
15910 #[allow(deprecated)]
15911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15912 where
15913 D: serde::Deserializer<'de>,
15914 {
15915 const FIELDS: &[&str] = &[
15916 "sst_retention_time_sec",
15917 "sstRetentionTimeSec",
15918 "prefix",
15919 ];
15920
15921 #[allow(clippy::enum_variant_names)]
15922 enum GeneratedField {
15923 SstRetentionTimeSec,
15924 Prefix,
15925 }
15926 impl<'de> serde::Deserialize<'de> for GeneratedField {
15927 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15928 where
15929 D: serde::Deserializer<'de>,
15930 {
15931 struct GeneratedVisitor;
15932
15933 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15934 type Value = GeneratedField;
15935
15936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15937 write!(formatter, "expected one of: {:?}", &FIELDS)
15938 }
15939
15940 #[allow(unused_variables)]
15941 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15942 where
15943 E: serde::de::Error,
15944 {
15945 match value {
15946 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
15947 "prefix" => Ok(GeneratedField::Prefix),
15948 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15949 }
15950 }
15951 }
15952 deserializer.deserialize_identifier(GeneratedVisitor)
15953 }
15954 }
15955 struct GeneratedVisitor;
15956 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15957 type Value = TriggerFullGcRequest;
15958
15959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15960 formatter.write_str("struct hummock.TriggerFullGCRequest")
15961 }
15962
15963 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
15964 where
15965 V: serde::de::MapAccess<'de>,
15966 {
15967 let mut sst_retention_time_sec__ = None;
15968 let mut prefix__ = None;
15969 while let Some(k) = map_.next_key()? {
15970 match k {
15971 GeneratedField::SstRetentionTimeSec => {
15972 if sst_retention_time_sec__.is_some() {
15973 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
15974 }
15975 sst_retention_time_sec__ =
15976 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15977 ;
15978 }
15979 GeneratedField::Prefix => {
15980 if prefix__.is_some() {
15981 return Err(serde::de::Error::duplicate_field("prefix"));
15982 }
15983 prefix__ = map_.next_value()?;
15984 }
15985 }
15986 }
15987 Ok(TriggerFullGcRequest {
15988 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
15989 prefix: prefix__,
15990 })
15991 }
15992 }
15993 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
15994 }
15995}
15996impl serde::Serialize for TriggerFullGcResponse {
15997 #[allow(deprecated)]
15998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15999 where
16000 S: serde::Serializer,
16001 {
16002 use serde::ser::SerializeStruct;
16003 let mut len = 0;
16004 if self.status.is_some() {
16005 len += 1;
16006 }
16007 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
16008 if let Some(v) = self.status.as_ref() {
16009 struct_ser.serialize_field("status", v)?;
16010 }
16011 struct_ser.end()
16012 }
16013}
16014impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
16015 #[allow(deprecated)]
16016 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16017 where
16018 D: serde::Deserializer<'de>,
16019 {
16020 const FIELDS: &[&str] = &[
16021 "status",
16022 ];
16023
16024 #[allow(clippy::enum_variant_names)]
16025 enum GeneratedField {
16026 Status,
16027 }
16028 impl<'de> serde::Deserialize<'de> for GeneratedField {
16029 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16030 where
16031 D: serde::Deserializer<'de>,
16032 {
16033 struct GeneratedVisitor;
16034
16035 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16036 type Value = GeneratedField;
16037
16038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16039 write!(formatter, "expected one of: {:?}", &FIELDS)
16040 }
16041
16042 #[allow(unused_variables)]
16043 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16044 where
16045 E: serde::de::Error,
16046 {
16047 match value {
16048 "status" => Ok(GeneratedField::Status),
16049 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16050 }
16051 }
16052 }
16053 deserializer.deserialize_identifier(GeneratedVisitor)
16054 }
16055 }
16056 struct GeneratedVisitor;
16057 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16058 type Value = TriggerFullGcResponse;
16059
16060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16061 formatter.write_str("struct hummock.TriggerFullGCResponse")
16062 }
16063
16064 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
16065 where
16066 V: serde::de::MapAccess<'de>,
16067 {
16068 let mut status__ = None;
16069 while let Some(k) = map_.next_key()? {
16070 match k {
16071 GeneratedField::Status => {
16072 if status__.is_some() {
16073 return Err(serde::de::Error::duplicate_field("status"));
16074 }
16075 status__ = map_.next_value()?;
16076 }
16077 }
16078 }
16079 Ok(TriggerFullGcResponse {
16080 status: status__,
16081 })
16082 }
16083 }
16084 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
16085 }
16086}
16087impl serde::Serialize for TriggerManualCompactionRequest {
16088 #[allow(deprecated)]
16089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16090 where
16091 S: serde::Serializer,
16092 {
16093 use serde::ser::SerializeStruct;
16094 let mut len = 0;
16095 if self.compaction_group_id != 0 {
16096 len += 1;
16097 }
16098 if self.key_range.is_some() {
16099 len += 1;
16100 }
16101 if self.table_id != 0 {
16102 len += 1;
16103 }
16104 if self.level != 0 {
16105 len += 1;
16106 }
16107 if !self.sst_ids.is_empty() {
16108 len += 1;
16109 }
16110 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
16111 if self.compaction_group_id != 0 {
16112 #[allow(clippy::needless_borrow)]
16113 #[allow(clippy::needless_borrows_for_generic_args)]
16114 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
16115 }
16116 if let Some(v) = self.key_range.as_ref() {
16117 struct_ser.serialize_field("keyRange", v)?;
16118 }
16119 if self.table_id != 0 {
16120 struct_ser.serialize_field("tableId", &self.table_id)?;
16121 }
16122 if self.level != 0 {
16123 struct_ser.serialize_field("level", &self.level)?;
16124 }
16125 if !self.sst_ids.is_empty() {
16126 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16127 }
16128 struct_ser.end()
16129 }
16130}
16131impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
16132 #[allow(deprecated)]
16133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16134 where
16135 D: serde::Deserializer<'de>,
16136 {
16137 const FIELDS: &[&str] = &[
16138 "compaction_group_id",
16139 "compactionGroupId",
16140 "key_range",
16141 "keyRange",
16142 "table_id",
16143 "tableId",
16144 "level",
16145 "sst_ids",
16146 "sstIds",
16147 ];
16148
16149 #[allow(clippy::enum_variant_names)]
16150 enum GeneratedField {
16151 CompactionGroupId,
16152 KeyRange,
16153 TableId,
16154 Level,
16155 SstIds,
16156 }
16157 impl<'de> serde::Deserialize<'de> for GeneratedField {
16158 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16159 where
16160 D: serde::Deserializer<'de>,
16161 {
16162 struct GeneratedVisitor;
16163
16164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16165 type Value = GeneratedField;
16166
16167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16168 write!(formatter, "expected one of: {:?}", &FIELDS)
16169 }
16170
16171 #[allow(unused_variables)]
16172 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16173 where
16174 E: serde::de::Error,
16175 {
16176 match value {
16177 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
16178 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
16179 "tableId" | "table_id" => Ok(GeneratedField::TableId),
16180 "level" => Ok(GeneratedField::Level),
16181 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
16182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16183 }
16184 }
16185 }
16186 deserializer.deserialize_identifier(GeneratedVisitor)
16187 }
16188 }
16189 struct GeneratedVisitor;
16190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16191 type Value = TriggerManualCompactionRequest;
16192
16193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16194 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
16195 }
16196
16197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
16198 where
16199 V: serde::de::MapAccess<'de>,
16200 {
16201 let mut compaction_group_id__ = None;
16202 let mut key_range__ = None;
16203 let mut table_id__ = None;
16204 let mut level__ = None;
16205 let mut sst_ids__ = None;
16206 while let Some(k) = map_.next_key()? {
16207 match k {
16208 GeneratedField::CompactionGroupId => {
16209 if compaction_group_id__.is_some() {
16210 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
16211 }
16212 compaction_group_id__ =
16213 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16214 ;
16215 }
16216 GeneratedField::KeyRange => {
16217 if key_range__.is_some() {
16218 return Err(serde::de::Error::duplicate_field("keyRange"));
16219 }
16220 key_range__ = map_.next_value()?;
16221 }
16222 GeneratedField::TableId => {
16223 if table_id__.is_some() {
16224 return Err(serde::de::Error::duplicate_field("tableId"));
16225 }
16226 table_id__ =
16227 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16228 ;
16229 }
16230 GeneratedField::Level => {
16231 if level__.is_some() {
16232 return Err(serde::de::Error::duplicate_field("level"));
16233 }
16234 level__ =
16235 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16236 ;
16237 }
16238 GeneratedField::SstIds => {
16239 if sst_ids__.is_some() {
16240 return Err(serde::de::Error::duplicate_field("sstIds"));
16241 }
16242 sst_ids__ =
16243 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16244 .into_iter().map(|x| x.0).collect())
16245 ;
16246 }
16247 }
16248 }
16249 Ok(TriggerManualCompactionRequest {
16250 compaction_group_id: compaction_group_id__.unwrap_or_default(),
16251 key_range: key_range__,
16252 table_id: table_id__.unwrap_or_default(),
16253 level: level__.unwrap_or_default(),
16254 sst_ids: sst_ids__.unwrap_or_default(),
16255 })
16256 }
16257 }
16258 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
16259 }
16260}
16261impl serde::Serialize for TriggerManualCompactionResponse {
16262 #[allow(deprecated)]
16263 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16264 where
16265 S: serde::Serializer,
16266 {
16267 use serde::ser::SerializeStruct;
16268 let mut len = 0;
16269 if self.status.is_some() {
16270 len += 1;
16271 }
16272 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
16273 if let Some(v) = self.status.as_ref() {
16274 struct_ser.serialize_field("status", v)?;
16275 }
16276 struct_ser.end()
16277 }
16278}
16279impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
16280 #[allow(deprecated)]
16281 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16282 where
16283 D: serde::Deserializer<'de>,
16284 {
16285 const FIELDS: &[&str] = &[
16286 "status",
16287 ];
16288
16289 #[allow(clippy::enum_variant_names)]
16290 enum GeneratedField {
16291 Status,
16292 }
16293 impl<'de> serde::Deserialize<'de> for GeneratedField {
16294 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16295 where
16296 D: serde::Deserializer<'de>,
16297 {
16298 struct GeneratedVisitor;
16299
16300 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16301 type Value = GeneratedField;
16302
16303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16304 write!(formatter, "expected one of: {:?}", &FIELDS)
16305 }
16306
16307 #[allow(unused_variables)]
16308 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16309 where
16310 E: serde::de::Error,
16311 {
16312 match value {
16313 "status" => Ok(GeneratedField::Status),
16314 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16315 }
16316 }
16317 }
16318 deserializer.deserialize_identifier(GeneratedVisitor)
16319 }
16320 }
16321 struct GeneratedVisitor;
16322 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16323 type Value = TriggerManualCompactionResponse;
16324
16325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16326 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
16327 }
16328
16329 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
16330 where
16331 V: serde::de::MapAccess<'de>,
16332 {
16333 let mut status__ = None;
16334 while let Some(k) = map_.next_key()? {
16335 match k {
16336 GeneratedField::Status => {
16337 if status__.is_some() {
16338 return Err(serde::de::Error::duplicate_field("status"));
16339 }
16340 status__ = map_.next_value()?;
16341 }
16342 }
16343 }
16344 Ok(TriggerManualCompactionResponse {
16345 status: status__,
16346 })
16347 }
16348 }
16349 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
16350 }
16351}
16352impl serde::Serialize for TruncateTables {
16353 #[allow(deprecated)]
16354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16355 where
16356 S: serde::Serializer,
16357 {
16358 use serde::ser::SerializeStruct;
16359 let mut len = 0;
16360 if !self.table_ids.is_empty() {
16361 len += 1;
16362 }
16363 let mut struct_ser = serializer.serialize_struct("hummock.TruncateTables", len)?;
16364 if !self.table_ids.is_empty() {
16365 struct_ser.serialize_field("tableIds", &self.table_ids)?;
16366 }
16367 struct_ser.end()
16368 }
16369}
16370impl<'de> serde::Deserialize<'de> for TruncateTables {
16371 #[allow(deprecated)]
16372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16373 where
16374 D: serde::Deserializer<'de>,
16375 {
16376 const FIELDS: &[&str] = &[
16377 "table_ids",
16378 "tableIds",
16379 ];
16380
16381 #[allow(clippy::enum_variant_names)]
16382 enum GeneratedField {
16383 TableIds,
16384 }
16385 impl<'de> serde::Deserialize<'de> for GeneratedField {
16386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16387 where
16388 D: serde::Deserializer<'de>,
16389 {
16390 struct GeneratedVisitor;
16391
16392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16393 type Value = GeneratedField;
16394
16395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16396 write!(formatter, "expected one of: {:?}", &FIELDS)
16397 }
16398
16399 #[allow(unused_variables)]
16400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16401 where
16402 E: serde::de::Error,
16403 {
16404 match value {
16405 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
16406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16407 }
16408 }
16409 }
16410 deserializer.deserialize_identifier(GeneratedVisitor)
16411 }
16412 }
16413 struct GeneratedVisitor;
16414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16415 type Value = TruncateTables;
16416
16417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16418 formatter.write_str("struct hummock.TruncateTables")
16419 }
16420
16421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TruncateTables, V::Error>
16422 where
16423 V: serde::de::MapAccess<'de>,
16424 {
16425 let mut table_ids__ = None;
16426 while let Some(k) = map_.next_key()? {
16427 match k {
16428 GeneratedField::TableIds => {
16429 if table_ids__.is_some() {
16430 return Err(serde::de::Error::duplicate_field("tableIds"));
16431 }
16432 table_ids__ =
16433 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16434 .into_iter().map(|x| x.0).collect())
16435 ;
16436 }
16437 }
16438 }
16439 Ok(TruncateTables {
16440 table_ids: table_ids__.unwrap_or_default(),
16441 })
16442 }
16443 }
16444 deserializer.deserialize_struct("hummock.TruncateTables", FIELDS, GeneratedVisitor)
16445 }
16446}
16447impl serde::Serialize for UnpinVersionBeforeRequest {
16448 #[allow(deprecated)]
16449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16450 where
16451 S: serde::Serializer,
16452 {
16453 use serde::ser::SerializeStruct;
16454 let mut len = 0;
16455 if self.context_id != 0 {
16456 len += 1;
16457 }
16458 if self.unpin_version_before != 0 {
16459 len += 1;
16460 }
16461 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
16462 if self.context_id != 0 {
16463 struct_ser.serialize_field("contextId", &self.context_id)?;
16464 }
16465 if self.unpin_version_before != 0 {
16466 #[allow(clippy::needless_borrow)]
16467 #[allow(clippy::needless_borrows_for_generic_args)]
16468 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
16469 }
16470 struct_ser.end()
16471 }
16472}
16473impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
16474 #[allow(deprecated)]
16475 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16476 where
16477 D: serde::Deserializer<'de>,
16478 {
16479 const FIELDS: &[&str] = &[
16480 "context_id",
16481 "contextId",
16482 "unpin_version_before",
16483 "unpinVersionBefore",
16484 ];
16485
16486 #[allow(clippy::enum_variant_names)]
16487 enum GeneratedField {
16488 ContextId,
16489 UnpinVersionBefore,
16490 }
16491 impl<'de> serde::Deserialize<'de> for GeneratedField {
16492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16493 where
16494 D: serde::Deserializer<'de>,
16495 {
16496 struct GeneratedVisitor;
16497
16498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16499 type Value = GeneratedField;
16500
16501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16502 write!(formatter, "expected one of: {:?}", &FIELDS)
16503 }
16504
16505 #[allow(unused_variables)]
16506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16507 where
16508 E: serde::de::Error,
16509 {
16510 match value {
16511 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
16512 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
16513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16514 }
16515 }
16516 }
16517 deserializer.deserialize_identifier(GeneratedVisitor)
16518 }
16519 }
16520 struct GeneratedVisitor;
16521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16522 type Value = UnpinVersionBeforeRequest;
16523
16524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16525 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
16526 }
16527
16528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
16529 where
16530 V: serde::de::MapAccess<'de>,
16531 {
16532 let mut context_id__ = None;
16533 let mut unpin_version_before__ = None;
16534 while let Some(k) = map_.next_key()? {
16535 match k {
16536 GeneratedField::ContextId => {
16537 if context_id__.is_some() {
16538 return Err(serde::de::Error::duplicate_field("contextId"));
16539 }
16540 context_id__ =
16541 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16542 ;
16543 }
16544 GeneratedField::UnpinVersionBefore => {
16545 if unpin_version_before__.is_some() {
16546 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
16547 }
16548 unpin_version_before__ =
16549 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16550 ;
16551 }
16552 }
16553 }
16554 Ok(UnpinVersionBeforeRequest {
16555 context_id: context_id__.unwrap_or_default(),
16556 unpin_version_before: unpin_version_before__.unwrap_or_default(),
16557 })
16558 }
16559 }
16560 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
16561 }
16562}
16563impl serde::Serialize for UnpinVersionBeforeResponse {
16564 #[allow(deprecated)]
16565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16566 where
16567 S: serde::Serializer,
16568 {
16569 use serde::ser::SerializeStruct;
16570 let mut len = 0;
16571 if self.status.is_some() {
16572 len += 1;
16573 }
16574 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
16575 if let Some(v) = self.status.as_ref() {
16576 struct_ser.serialize_field("status", v)?;
16577 }
16578 struct_ser.end()
16579 }
16580}
16581impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
16582 #[allow(deprecated)]
16583 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16584 where
16585 D: serde::Deserializer<'de>,
16586 {
16587 const FIELDS: &[&str] = &[
16588 "status",
16589 ];
16590
16591 #[allow(clippy::enum_variant_names)]
16592 enum GeneratedField {
16593 Status,
16594 }
16595 impl<'de> serde::Deserialize<'de> for GeneratedField {
16596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16597 where
16598 D: serde::Deserializer<'de>,
16599 {
16600 struct GeneratedVisitor;
16601
16602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16603 type Value = GeneratedField;
16604
16605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16606 write!(formatter, "expected one of: {:?}", &FIELDS)
16607 }
16608
16609 #[allow(unused_variables)]
16610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16611 where
16612 E: serde::de::Error,
16613 {
16614 match value {
16615 "status" => Ok(GeneratedField::Status),
16616 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16617 }
16618 }
16619 }
16620 deserializer.deserialize_identifier(GeneratedVisitor)
16621 }
16622 }
16623 struct GeneratedVisitor;
16624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16625 type Value = UnpinVersionBeforeResponse;
16626
16627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16628 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
16629 }
16630
16631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
16632 where
16633 V: serde::de::MapAccess<'de>,
16634 {
16635 let mut status__ = None;
16636 while let Some(k) = map_.next_key()? {
16637 match k {
16638 GeneratedField::Status => {
16639 if status__.is_some() {
16640 return Err(serde::de::Error::duplicate_field("status"));
16641 }
16642 status__ = map_.next_value()?;
16643 }
16644 }
16645 }
16646 Ok(UnpinVersionBeforeResponse {
16647 status: status__,
16648 })
16649 }
16650 }
16651 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
16652 }
16653}
16654impl serde::Serialize for UnpinVersionRequest {
16655 #[allow(deprecated)]
16656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16657 where
16658 S: serde::Serializer,
16659 {
16660 use serde::ser::SerializeStruct;
16661 let mut len = 0;
16662 if self.context_id != 0 {
16663 len += 1;
16664 }
16665 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
16666 if self.context_id != 0 {
16667 struct_ser.serialize_field("contextId", &self.context_id)?;
16668 }
16669 struct_ser.end()
16670 }
16671}
16672impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
16673 #[allow(deprecated)]
16674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16675 where
16676 D: serde::Deserializer<'de>,
16677 {
16678 const FIELDS: &[&str] = &[
16679 "context_id",
16680 "contextId",
16681 ];
16682
16683 #[allow(clippy::enum_variant_names)]
16684 enum GeneratedField {
16685 ContextId,
16686 }
16687 impl<'de> serde::Deserialize<'de> for GeneratedField {
16688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16689 where
16690 D: serde::Deserializer<'de>,
16691 {
16692 struct GeneratedVisitor;
16693
16694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16695 type Value = GeneratedField;
16696
16697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16698 write!(formatter, "expected one of: {:?}", &FIELDS)
16699 }
16700
16701 #[allow(unused_variables)]
16702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16703 where
16704 E: serde::de::Error,
16705 {
16706 match value {
16707 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
16708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16709 }
16710 }
16711 }
16712 deserializer.deserialize_identifier(GeneratedVisitor)
16713 }
16714 }
16715 struct GeneratedVisitor;
16716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16717 type Value = UnpinVersionRequest;
16718
16719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16720 formatter.write_str("struct hummock.UnpinVersionRequest")
16721 }
16722
16723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
16724 where
16725 V: serde::de::MapAccess<'de>,
16726 {
16727 let mut context_id__ = None;
16728 while let Some(k) = map_.next_key()? {
16729 match k {
16730 GeneratedField::ContextId => {
16731 if context_id__.is_some() {
16732 return Err(serde::de::Error::duplicate_field("contextId"));
16733 }
16734 context_id__ =
16735 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16736 ;
16737 }
16738 }
16739 }
16740 Ok(UnpinVersionRequest {
16741 context_id: context_id__.unwrap_or_default(),
16742 })
16743 }
16744 }
16745 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
16746 }
16747}
16748impl serde::Serialize for UnpinVersionResponse {
16749 #[allow(deprecated)]
16750 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16751 where
16752 S: serde::Serializer,
16753 {
16754 use serde::ser::SerializeStruct;
16755 let mut len = 0;
16756 if self.status.is_some() {
16757 len += 1;
16758 }
16759 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
16760 if let Some(v) = self.status.as_ref() {
16761 struct_ser.serialize_field("status", v)?;
16762 }
16763 struct_ser.end()
16764 }
16765}
16766impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
16767 #[allow(deprecated)]
16768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16769 where
16770 D: serde::Deserializer<'de>,
16771 {
16772 const FIELDS: &[&str] = &[
16773 "status",
16774 ];
16775
16776 #[allow(clippy::enum_variant_names)]
16777 enum GeneratedField {
16778 Status,
16779 }
16780 impl<'de> serde::Deserialize<'de> for GeneratedField {
16781 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16782 where
16783 D: serde::Deserializer<'de>,
16784 {
16785 struct GeneratedVisitor;
16786
16787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16788 type Value = GeneratedField;
16789
16790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16791 write!(formatter, "expected one of: {:?}", &FIELDS)
16792 }
16793
16794 #[allow(unused_variables)]
16795 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16796 where
16797 E: serde::de::Error,
16798 {
16799 match value {
16800 "status" => Ok(GeneratedField::Status),
16801 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16802 }
16803 }
16804 }
16805 deserializer.deserialize_identifier(GeneratedVisitor)
16806 }
16807 }
16808 struct GeneratedVisitor;
16809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16810 type Value = UnpinVersionResponse;
16811
16812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16813 formatter.write_str("struct hummock.UnpinVersionResponse")
16814 }
16815
16816 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
16817 where
16818 V: serde::de::MapAccess<'de>,
16819 {
16820 let mut status__ = None;
16821 while let Some(k) = map_.next_key()? {
16822 match k {
16823 GeneratedField::Status => {
16824 if status__.is_some() {
16825 return Err(serde::de::Error::duplicate_field("status"));
16826 }
16827 status__ = map_.next_value()?;
16828 }
16829 }
16830 }
16831 Ok(UnpinVersionResponse {
16832 status: status__,
16833 })
16834 }
16835 }
16836 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
16837 }
16838}
16839impl serde::Serialize for VacuumTask {
16840 #[allow(deprecated)]
16841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16842 where
16843 S: serde::Serializer,
16844 {
16845 use serde::ser::SerializeStruct;
16846 let mut len = 0;
16847 if !self.sstable_object_ids.is_empty() {
16848 len += 1;
16849 }
16850 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
16851 if !self.sstable_object_ids.is_empty() {
16852 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16853 }
16854 struct_ser.end()
16855 }
16856}
16857impl<'de> serde::Deserialize<'de> for VacuumTask {
16858 #[allow(deprecated)]
16859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16860 where
16861 D: serde::Deserializer<'de>,
16862 {
16863 const FIELDS: &[&str] = &[
16864 "sstable_object_ids",
16865 "sstableObjectIds",
16866 ];
16867
16868 #[allow(clippy::enum_variant_names)]
16869 enum GeneratedField {
16870 SstableObjectIds,
16871 }
16872 impl<'de> serde::Deserialize<'de> for GeneratedField {
16873 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16874 where
16875 D: serde::Deserializer<'de>,
16876 {
16877 struct GeneratedVisitor;
16878
16879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16880 type Value = GeneratedField;
16881
16882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16883 write!(formatter, "expected one of: {:?}", &FIELDS)
16884 }
16885
16886 #[allow(unused_variables)]
16887 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16888 where
16889 E: serde::de::Error,
16890 {
16891 match value {
16892 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
16893 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16894 }
16895 }
16896 }
16897 deserializer.deserialize_identifier(GeneratedVisitor)
16898 }
16899 }
16900 struct GeneratedVisitor;
16901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16902 type Value = VacuumTask;
16903
16904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16905 formatter.write_str("struct hummock.VacuumTask")
16906 }
16907
16908 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
16909 where
16910 V: serde::de::MapAccess<'de>,
16911 {
16912 let mut sstable_object_ids__ = None;
16913 while let Some(k) = map_.next_key()? {
16914 match k {
16915 GeneratedField::SstableObjectIds => {
16916 if sstable_object_ids__.is_some() {
16917 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
16918 }
16919 sstable_object_ids__ =
16920 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16921 .into_iter().map(|x| x.0).collect())
16922 ;
16923 }
16924 }
16925 }
16926 Ok(VacuumTask {
16927 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
16928 })
16929 }
16930 }
16931 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
16932 }
16933}
16934impl serde::Serialize for ValidationTask {
16935 #[allow(deprecated)]
16936 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16937 where
16938 S: serde::Serializer,
16939 {
16940 use serde::ser::SerializeStruct;
16941 let mut len = 0;
16942 if !self.sst_infos.is_empty() {
16943 len += 1;
16944 }
16945 if !self.sst_id_to_worker_id.is_empty() {
16946 len += 1;
16947 }
16948 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
16949 if !self.sst_infos.is_empty() {
16950 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
16951 }
16952 if !self.sst_id_to_worker_id.is_empty() {
16953 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
16954 }
16955 struct_ser.end()
16956 }
16957}
16958impl<'de> serde::Deserialize<'de> for ValidationTask {
16959 #[allow(deprecated)]
16960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16961 where
16962 D: serde::Deserializer<'de>,
16963 {
16964 const FIELDS: &[&str] = &[
16965 "sst_infos",
16966 "sstInfos",
16967 "sst_id_to_worker_id",
16968 "sstIdToWorkerId",
16969 ];
16970
16971 #[allow(clippy::enum_variant_names)]
16972 enum GeneratedField {
16973 SstInfos,
16974 SstIdToWorkerId,
16975 }
16976 impl<'de> serde::Deserialize<'de> for GeneratedField {
16977 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16978 where
16979 D: serde::Deserializer<'de>,
16980 {
16981 struct GeneratedVisitor;
16982
16983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16984 type Value = GeneratedField;
16985
16986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16987 write!(formatter, "expected one of: {:?}", &FIELDS)
16988 }
16989
16990 #[allow(unused_variables)]
16991 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16992 where
16993 E: serde::de::Error,
16994 {
16995 match value {
16996 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
16997 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
16998 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16999 }
17000 }
17001 }
17002 deserializer.deserialize_identifier(GeneratedVisitor)
17003 }
17004 }
17005 struct GeneratedVisitor;
17006 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17007 type Value = ValidationTask;
17008
17009 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17010 formatter.write_str("struct hummock.ValidationTask")
17011 }
17012
17013 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
17014 where
17015 V: serde::de::MapAccess<'de>,
17016 {
17017 let mut sst_infos__ = None;
17018 let mut sst_id_to_worker_id__ = None;
17019 while let Some(k) = map_.next_key()? {
17020 match k {
17021 GeneratedField::SstInfos => {
17022 if sst_infos__.is_some() {
17023 return Err(serde::de::Error::duplicate_field("sstInfos"));
17024 }
17025 sst_infos__ = Some(map_.next_value()?);
17026 }
17027 GeneratedField::SstIdToWorkerId => {
17028 if sst_id_to_worker_id__.is_some() {
17029 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
17030 }
17031 sst_id_to_worker_id__ = Some(
17032 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
17033 .into_iter().map(|(k,v)| (k.0.into(), v.0)).collect()
17034 );
17035 }
17036 }
17037 }
17038 Ok(ValidationTask {
17039 sst_infos: sst_infos__.unwrap_or_default(),
17040 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
17041 })
17042 }
17043 }
17044 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
17045 }
17046}
17047impl serde::Serialize for VectorFileInfo {
17048 #[allow(deprecated)]
17049 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17050 where
17051 S: serde::Serializer,
17052 {
17053 use serde::ser::SerializeStruct;
17054 let mut len = 0;
17055 if self.object_id != 0 {
17056 len += 1;
17057 }
17058 if self.file_size != 0 {
17059 len += 1;
17060 }
17061 if self.start_vector_id != 0 {
17062 len += 1;
17063 }
17064 if self.vector_count != 0 {
17065 len += 1;
17066 }
17067 if self.meta_offset != 0 {
17068 len += 1;
17069 }
17070 let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
17071 if self.object_id != 0 {
17072 #[allow(clippy::needless_borrow)]
17073 #[allow(clippy::needless_borrows_for_generic_args)]
17074 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
17075 }
17076 if self.file_size != 0 {
17077 #[allow(clippy::needless_borrow)]
17078 #[allow(clippy::needless_borrows_for_generic_args)]
17079 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
17080 }
17081 if self.start_vector_id != 0 {
17082 #[allow(clippy::needless_borrow)]
17083 #[allow(clippy::needless_borrows_for_generic_args)]
17084 struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
17085 }
17086 if self.vector_count != 0 {
17087 struct_ser.serialize_field("vectorCount", &self.vector_count)?;
17088 }
17089 if self.meta_offset != 0 {
17090 #[allow(clippy::needless_borrow)]
17091 #[allow(clippy::needless_borrows_for_generic_args)]
17092 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
17093 }
17094 struct_ser.end()
17095 }
17096}
17097impl<'de> serde::Deserialize<'de> for VectorFileInfo {
17098 #[allow(deprecated)]
17099 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17100 where
17101 D: serde::Deserializer<'de>,
17102 {
17103 const FIELDS: &[&str] = &[
17104 "object_id",
17105 "objectId",
17106 "file_size",
17107 "fileSize",
17108 "start_vector_id",
17109 "startVectorId",
17110 "vector_count",
17111 "vectorCount",
17112 "meta_offset",
17113 "metaOffset",
17114 ];
17115
17116 #[allow(clippy::enum_variant_names)]
17117 enum GeneratedField {
17118 ObjectId,
17119 FileSize,
17120 StartVectorId,
17121 VectorCount,
17122 MetaOffset,
17123 }
17124 impl<'de> serde::Deserialize<'de> for GeneratedField {
17125 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17126 where
17127 D: serde::Deserializer<'de>,
17128 {
17129 struct GeneratedVisitor;
17130
17131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17132 type Value = GeneratedField;
17133
17134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17135 write!(formatter, "expected one of: {:?}", &FIELDS)
17136 }
17137
17138 #[allow(unused_variables)]
17139 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17140 where
17141 E: serde::de::Error,
17142 {
17143 match value {
17144 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
17145 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
17146 "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
17147 "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
17148 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
17149 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17150 }
17151 }
17152 }
17153 deserializer.deserialize_identifier(GeneratedVisitor)
17154 }
17155 }
17156 struct GeneratedVisitor;
17157 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17158 type Value = VectorFileInfo;
17159
17160 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17161 formatter.write_str("struct hummock.VectorFileInfo")
17162 }
17163
17164 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
17165 where
17166 V: serde::de::MapAccess<'de>,
17167 {
17168 let mut object_id__ = None;
17169 let mut file_size__ = None;
17170 let mut start_vector_id__ = None;
17171 let mut vector_count__ = None;
17172 let mut meta_offset__ = None;
17173 while let Some(k) = map_.next_key()? {
17174 match k {
17175 GeneratedField::ObjectId => {
17176 if object_id__.is_some() {
17177 return Err(serde::de::Error::duplicate_field("objectId"));
17178 }
17179 object_id__ =
17180 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17181 ;
17182 }
17183 GeneratedField::FileSize => {
17184 if file_size__.is_some() {
17185 return Err(serde::de::Error::duplicate_field("fileSize"));
17186 }
17187 file_size__ =
17188 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17189 ;
17190 }
17191 GeneratedField::StartVectorId => {
17192 if start_vector_id__.is_some() {
17193 return Err(serde::de::Error::duplicate_field("startVectorId"));
17194 }
17195 start_vector_id__ =
17196 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17197 ;
17198 }
17199 GeneratedField::VectorCount => {
17200 if vector_count__.is_some() {
17201 return Err(serde::de::Error::duplicate_field("vectorCount"));
17202 }
17203 vector_count__ =
17204 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17205 ;
17206 }
17207 GeneratedField::MetaOffset => {
17208 if meta_offset__.is_some() {
17209 return Err(serde::de::Error::duplicate_field("metaOffset"));
17210 }
17211 meta_offset__ =
17212 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17213 ;
17214 }
17215 }
17216 }
17217 Ok(VectorFileInfo {
17218 object_id: object_id__.unwrap_or_default(),
17219 file_size: file_size__.unwrap_or_default(),
17220 start_vector_id: start_vector_id__.unwrap_or_default(),
17221 vector_count: vector_count__.unwrap_or_default(),
17222 meta_offset: meta_offset__.unwrap_or_default(),
17223 })
17224 }
17225 }
17226 deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
17227 }
17228}
17229impl serde::Serialize for VectorIndex {
17230 #[allow(deprecated)]
17231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17232 where
17233 S: serde::Serializer,
17234 {
17235 use serde::ser::SerializeStruct;
17236 let mut len = 0;
17237 if self.dimension != 0 {
17238 len += 1;
17239 }
17240 if self.distance_type != 0 {
17241 len += 1;
17242 }
17243 if self.variant.is_some() {
17244 len += 1;
17245 }
17246 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
17247 if self.dimension != 0 {
17248 struct_ser.serialize_field("dimension", &self.dimension)?;
17249 }
17250 if self.distance_type != 0 {
17251 let v = super::common::DistanceType::try_from(self.distance_type)
17252 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
17253 struct_ser.serialize_field("distanceType", &v)?;
17254 }
17255 if let Some(v) = self.variant.as_ref() {
17256 match v {
17257 vector_index::Variant::Flat(v) => {
17258 struct_ser.serialize_field("flat", v)?;
17259 }
17260 vector_index::Variant::HnswFlat(v) => {
17261 struct_ser.serialize_field("hnswFlat", v)?;
17262 }
17263 }
17264 }
17265 struct_ser.end()
17266 }
17267}
17268impl<'de> serde::Deserialize<'de> for VectorIndex {
17269 #[allow(deprecated)]
17270 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17271 where
17272 D: serde::Deserializer<'de>,
17273 {
17274 const FIELDS: &[&str] = &[
17275 "dimension",
17276 "distance_type",
17277 "distanceType",
17278 "flat",
17279 "hnsw_flat",
17280 "hnswFlat",
17281 ];
17282
17283 #[allow(clippy::enum_variant_names)]
17284 enum GeneratedField {
17285 Dimension,
17286 DistanceType,
17287 Flat,
17288 HnswFlat,
17289 }
17290 impl<'de> serde::Deserialize<'de> for GeneratedField {
17291 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17292 where
17293 D: serde::Deserializer<'de>,
17294 {
17295 struct GeneratedVisitor;
17296
17297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17298 type Value = GeneratedField;
17299
17300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17301 write!(formatter, "expected one of: {:?}", &FIELDS)
17302 }
17303
17304 #[allow(unused_variables)]
17305 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17306 where
17307 E: serde::de::Error,
17308 {
17309 match value {
17310 "dimension" => Ok(GeneratedField::Dimension),
17311 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
17312 "flat" => Ok(GeneratedField::Flat),
17313 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
17314 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17315 }
17316 }
17317 }
17318 deserializer.deserialize_identifier(GeneratedVisitor)
17319 }
17320 }
17321 struct GeneratedVisitor;
17322 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17323 type Value = VectorIndex;
17324
17325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17326 formatter.write_str("struct hummock.VectorIndex")
17327 }
17328
17329 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
17330 where
17331 V: serde::de::MapAccess<'de>,
17332 {
17333 let mut dimension__ = None;
17334 let mut distance_type__ = None;
17335 let mut variant__ = None;
17336 while let Some(k) = map_.next_key()? {
17337 match k {
17338 GeneratedField::Dimension => {
17339 if dimension__.is_some() {
17340 return Err(serde::de::Error::duplicate_field("dimension"));
17341 }
17342 dimension__ =
17343 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17344 ;
17345 }
17346 GeneratedField::DistanceType => {
17347 if distance_type__.is_some() {
17348 return Err(serde::de::Error::duplicate_field("distanceType"));
17349 }
17350 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
17351 }
17352 GeneratedField::Flat => {
17353 if variant__.is_some() {
17354 return Err(serde::de::Error::duplicate_field("flat"));
17355 }
17356 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
17357;
17358 }
17359 GeneratedField::HnswFlat => {
17360 if variant__.is_some() {
17361 return Err(serde::de::Error::duplicate_field("hnswFlat"));
17362 }
17363 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::HnswFlat)
17364;
17365 }
17366 }
17367 }
17368 Ok(VectorIndex {
17369 dimension: dimension__.unwrap_or_default(),
17370 distance_type: distance_type__.unwrap_or_default(),
17371 variant: variant__,
17372 })
17373 }
17374 }
17375 deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
17376 }
17377}
17378impl serde::Serialize for VectorIndexDelta {
17379 #[allow(deprecated)]
17380 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17381 where
17382 S: serde::Serializer,
17383 {
17384 use serde::ser::SerializeStruct;
17385 let mut len = 0;
17386 if self.delta.is_some() {
17387 len += 1;
17388 }
17389 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
17390 if let Some(v) = self.delta.as_ref() {
17391 match v {
17392 vector_index_delta::Delta::Init(v) => {
17393 struct_ser.serialize_field("init", v)?;
17394 }
17395 vector_index_delta::Delta::Adds(v) => {
17396 struct_ser.serialize_field("adds", v)?;
17397 }
17398 }
17399 }
17400 struct_ser.end()
17401 }
17402}
17403impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
17404 #[allow(deprecated)]
17405 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17406 where
17407 D: serde::Deserializer<'de>,
17408 {
17409 const FIELDS: &[&str] = &[
17410 "init",
17411 "adds",
17412 ];
17413
17414 #[allow(clippy::enum_variant_names)]
17415 enum GeneratedField {
17416 Init,
17417 Adds,
17418 }
17419 impl<'de> serde::Deserialize<'de> for GeneratedField {
17420 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17421 where
17422 D: serde::Deserializer<'de>,
17423 {
17424 struct GeneratedVisitor;
17425
17426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17427 type Value = GeneratedField;
17428
17429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17430 write!(formatter, "expected one of: {:?}", &FIELDS)
17431 }
17432
17433 #[allow(unused_variables)]
17434 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17435 where
17436 E: serde::de::Error,
17437 {
17438 match value {
17439 "init" => Ok(GeneratedField::Init),
17440 "adds" => Ok(GeneratedField::Adds),
17441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17442 }
17443 }
17444 }
17445 deserializer.deserialize_identifier(GeneratedVisitor)
17446 }
17447 }
17448 struct GeneratedVisitor;
17449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17450 type Value = VectorIndexDelta;
17451
17452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17453 formatter.write_str("struct hummock.VectorIndexDelta")
17454 }
17455
17456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
17457 where
17458 V: serde::de::MapAccess<'de>,
17459 {
17460 let mut delta__ = None;
17461 while let Some(k) = map_.next_key()? {
17462 match k {
17463 GeneratedField::Init => {
17464 if delta__.is_some() {
17465 return Err(serde::de::Error::duplicate_field("init"));
17466 }
17467 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
17468;
17469 }
17470 GeneratedField::Adds => {
17471 if delta__.is_some() {
17472 return Err(serde::de::Error::duplicate_field("adds"));
17473 }
17474 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
17475;
17476 }
17477 }
17478 }
17479 Ok(VectorIndexDelta {
17480 delta: delta__,
17481 })
17482 }
17483 }
17484 deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
17485 }
17486}
17487impl serde::Serialize for vector_index_delta::VectorIndexAdd {
17488 #[allow(deprecated)]
17489 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17490 where
17491 S: serde::Serializer,
17492 {
17493 use serde::ser::SerializeStruct;
17494 let mut len = 0;
17495 if self.add.is_some() {
17496 len += 1;
17497 }
17498 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
17499 if let Some(v) = self.add.as_ref() {
17500 match v {
17501 vector_index_delta::vector_index_add::Add::Flat(v) => {
17502 struct_ser.serialize_field("flat", v)?;
17503 }
17504 vector_index_delta::vector_index_add::Add::HnswFlat(v) => {
17505 struct_ser.serialize_field("hnswFlat", v)?;
17506 }
17507 }
17508 }
17509 struct_ser.end()
17510 }
17511}
17512impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
17513 #[allow(deprecated)]
17514 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17515 where
17516 D: serde::Deserializer<'de>,
17517 {
17518 const FIELDS: &[&str] = &[
17519 "flat",
17520 "hnsw_flat",
17521 "hnswFlat",
17522 ];
17523
17524 #[allow(clippy::enum_variant_names)]
17525 enum GeneratedField {
17526 Flat,
17527 HnswFlat,
17528 }
17529 impl<'de> serde::Deserialize<'de> for GeneratedField {
17530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17531 where
17532 D: serde::Deserializer<'de>,
17533 {
17534 struct GeneratedVisitor;
17535
17536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17537 type Value = GeneratedField;
17538
17539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17540 write!(formatter, "expected one of: {:?}", &FIELDS)
17541 }
17542
17543 #[allow(unused_variables)]
17544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17545 where
17546 E: serde::de::Error,
17547 {
17548 match value {
17549 "flat" => Ok(GeneratedField::Flat),
17550 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
17551 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17552 }
17553 }
17554 }
17555 deserializer.deserialize_identifier(GeneratedVisitor)
17556 }
17557 }
17558 struct GeneratedVisitor;
17559 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17560 type Value = vector_index_delta::VectorIndexAdd;
17561
17562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17563 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
17564 }
17565
17566 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
17567 where
17568 V: serde::de::MapAccess<'de>,
17569 {
17570 let mut add__ = None;
17571 while let Some(k) = map_.next_key()? {
17572 match k {
17573 GeneratedField::Flat => {
17574 if add__.is_some() {
17575 return Err(serde::de::Error::duplicate_field("flat"));
17576 }
17577 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
17578;
17579 }
17580 GeneratedField::HnswFlat => {
17581 if add__.is_some() {
17582 return Err(serde::de::Error::duplicate_field("hnswFlat"));
17583 }
17584 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::HnswFlat)
17585;
17586 }
17587 }
17588 }
17589 Ok(vector_index_delta::VectorIndexAdd {
17590 add: add__,
17591 })
17592 }
17593 }
17594 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
17595 }
17596}
17597impl serde::Serialize for vector_index_delta::VectorIndexAdds {
17598 #[allow(deprecated)]
17599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17600 where
17601 S: serde::Serializer,
17602 {
17603 use serde::ser::SerializeStruct;
17604 let mut len = 0;
17605 if !self.adds.is_empty() {
17606 len += 1;
17607 }
17608 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
17609 if !self.adds.is_empty() {
17610 struct_ser.serialize_field("adds", &self.adds)?;
17611 }
17612 struct_ser.end()
17613 }
17614}
17615impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
17616 #[allow(deprecated)]
17617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17618 where
17619 D: serde::Deserializer<'de>,
17620 {
17621 const FIELDS: &[&str] = &[
17622 "adds",
17623 ];
17624
17625 #[allow(clippy::enum_variant_names)]
17626 enum GeneratedField {
17627 Adds,
17628 }
17629 impl<'de> serde::Deserialize<'de> for GeneratedField {
17630 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17631 where
17632 D: serde::Deserializer<'de>,
17633 {
17634 struct GeneratedVisitor;
17635
17636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17637 type Value = GeneratedField;
17638
17639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17640 write!(formatter, "expected one of: {:?}", &FIELDS)
17641 }
17642
17643 #[allow(unused_variables)]
17644 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17645 where
17646 E: serde::de::Error,
17647 {
17648 match value {
17649 "adds" => Ok(GeneratedField::Adds),
17650 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17651 }
17652 }
17653 }
17654 deserializer.deserialize_identifier(GeneratedVisitor)
17655 }
17656 }
17657 struct GeneratedVisitor;
17658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17659 type Value = vector_index_delta::VectorIndexAdds;
17660
17661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17662 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
17663 }
17664
17665 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
17666 where
17667 V: serde::de::MapAccess<'de>,
17668 {
17669 let mut adds__ = None;
17670 while let Some(k) = map_.next_key()? {
17671 match k {
17672 GeneratedField::Adds => {
17673 if adds__.is_some() {
17674 return Err(serde::de::Error::duplicate_field("adds"));
17675 }
17676 adds__ = Some(map_.next_value()?);
17677 }
17678 }
17679 }
17680 Ok(vector_index_delta::VectorIndexAdds {
17681 adds: adds__.unwrap_or_default(),
17682 })
17683 }
17684 }
17685 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
17686 }
17687}
17688impl serde::Serialize for vector_index_delta::VectorIndexInit {
17689 #[allow(deprecated)]
17690 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17691 where
17692 S: serde::Serializer,
17693 {
17694 use serde::ser::SerializeStruct;
17695 let mut len = 0;
17696 if self.info.is_some() {
17697 len += 1;
17698 }
17699 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
17700 if let Some(v) = self.info.as_ref() {
17701 struct_ser.serialize_field("info", v)?;
17702 }
17703 struct_ser.end()
17704 }
17705}
17706impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
17707 #[allow(deprecated)]
17708 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17709 where
17710 D: serde::Deserializer<'de>,
17711 {
17712 const FIELDS: &[&str] = &[
17713 "info",
17714 ];
17715
17716 #[allow(clippy::enum_variant_names)]
17717 enum GeneratedField {
17718 Info,
17719 }
17720 impl<'de> serde::Deserialize<'de> for GeneratedField {
17721 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17722 where
17723 D: serde::Deserializer<'de>,
17724 {
17725 struct GeneratedVisitor;
17726
17727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17728 type Value = GeneratedField;
17729
17730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17731 write!(formatter, "expected one of: {:?}", &FIELDS)
17732 }
17733
17734 #[allow(unused_variables)]
17735 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17736 where
17737 E: serde::de::Error,
17738 {
17739 match value {
17740 "info" => Ok(GeneratedField::Info),
17741 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17742 }
17743 }
17744 }
17745 deserializer.deserialize_identifier(GeneratedVisitor)
17746 }
17747 }
17748 struct GeneratedVisitor;
17749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17750 type Value = vector_index_delta::VectorIndexInit;
17751
17752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17753 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
17754 }
17755
17756 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
17757 where
17758 V: serde::de::MapAccess<'de>,
17759 {
17760 let mut info__ = None;
17761 while let Some(k) = map_.next_key()? {
17762 match k {
17763 GeneratedField::Info => {
17764 if info__.is_some() {
17765 return Err(serde::de::Error::duplicate_field("info"));
17766 }
17767 info__ = map_.next_value()?;
17768 }
17769 }
17770 }
17771 Ok(vector_index_delta::VectorIndexInit {
17772 info: info__,
17773 })
17774 }
17775 }
17776 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
17777 }
17778}
17779impl serde::Serialize for VectorIndexObject {
17780 #[allow(deprecated)]
17781 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17782 where
17783 S: serde::Serializer,
17784 {
17785 use serde::ser::SerializeStruct;
17786 let mut len = 0;
17787 if self.id != 0 {
17788 len += 1;
17789 }
17790 if self.object_type != 0 {
17791 len += 1;
17792 }
17793 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
17794 if self.id != 0 {
17795 #[allow(clippy::needless_borrow)]
17796 #[allow(clippy::needless_borrows_for_generic_args)]
17797 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
17798 }
17799 if self.object_type != 0 {
17800 let v = VectorIndexObjectType::try_from(self.object_type)
17801 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
17802 struct_ser.serialize_field("objectType", &v)?;
17803 }
17804 struct_ser.end()
17805 }
17806}
17807impl<'de> serde::Deserialize<'de> for VectorIndexObject {
17808 #[allow(deprecated)]
17809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17810 where
17811 D: serde::Deserializer<'de>,
17812 {
17813 const FIELDS: &[&str] = &[
17814 "id",
17815 "object_type",
17816 "objectType",
17817 ];
17818
17819 #[allow(clippy::enum_variant_names)]
17820 enum GeneratedField {
17821 Id,
17822 ObjectType,
17823 }
17824 impl<'de> serde::Deserialize<'de> for GeneratedField {
17825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17826 where
17827 D: serde::Deserializer<'de>,
17828 {
17829 struct GeneratedVisitor;
17830
17831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17832 type Value = GeneratedField;
17833
17834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17835 write!(formatter, "expected one of: {:?}", &FIELDS)
17836 }
17837
17838 #[allow(unused_variables)]
17839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17840 where
17841 E: serde::de::Error,
17842 {
17843 match value {
17844 "id" => Ok(GeneratedField::Id),
17845 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
17846 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17847 }
17848 }
17849 }
17850 deserializer.deserialize_identifier(GeneratedVisitor)
17851 }
17852 }
17853 struct GeneratedVisitor;
17854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17855 type Value = VectorIndexObject;
17856
17857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17858 formatter.write_str("struct hummock.VectorIndexObject")
17859 }
17860
17861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
17862 where
17863 V: serde::de::MapAccess<'de>,
17864 {
17865 let mut id__ = None;
17866 let mut object_type__ = None;
17867 while let Some(k) = map_.next_key()? {
17868 match k {
17869 GeneratedField::Id => {
17870 if id__.is_some() {
17871 return Err(serde::de::Error::duplicate_field("id"));
17872 }
17873 id__ =
17874 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17875 ;
17876 }
17877 GeneratedField::ObjectType => {
17878 if object_type__.is_some() {
17879 return Err(serde::de::Error::duplicate_field("objectType"));
17880 }
17881 object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
17882 }
17883 }
17884 }
17885 Ok(VectorIndexObject {
17886 id: id__.unwrap_or_default(),
17887 object_type: object_type__.unwrap_or_default(),
17888 })
17889 }
17890 }
17891 deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
17892 }
17893}
17894impl serde::Serialize for VectorIndexObjectType {
17895 #[allow(deprecated)]
17896 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17897 where
17898 S: serde::Serializer,
17899 {
17900 let variant = match self {
17901 Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17902 Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
17903 Self::VectorIndexObjectHnswGraph => "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
17904 };
17905 serializer.serialize_str(variant)
17906 }
17907}
17908impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
17909 #[allow(deprecated)]
17910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17911 where
17912 D: serde::Deserializer<'de>,
17913 {
17914 const FIELDS: &[&str] = &[
17915 "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17916 "VECTOR_INDEX_OBJECT_VECTOR",
17917 "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
17918 ];
17919
17920 struct GeneratedVisitor;
17921
17922 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17923 type Value = VectorIndexObjectType;
17924
17925 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17926 write!(formatter, "expected one of: {:?}", &FIELDS)
17927 }
17928
17929 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17930 where
17931 E: serde::de::Error,
17932 {
17933 i32::try_from(v)
17934 .ok()
17935 .and_then(|x| x.try_into().ok())
17936 .ok_or_else(|| {
17937 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17938 })
17939 }
17940
17941 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17942 where
17943 E: serde::de::Error,
17944 {
17945 i32::try_from(v)
17946 .ok()
17947 .and_then(|x| x.try_into().ok())
17948 .ok_or_else(|| {
17949 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17950 })
17951 }
17952
17953 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17954 where
17955 E: serde::de::Error,
17956 {
17957 match value {
17958 "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
17959 "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
17960 "VECTOR_INDEX_OBJECT_HNSW_GRAPH" => Ok(VectorIndexObjectType::VectorIndexObjectHnswGraph),
17961 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17962 }
17963 }
17964 }
17965 deserializer.deserialize_any(GeneratedVisitor)
17966 }
17967}
17968impl serde::Serialize for VersionUpdatePayload {
17969 #[allow(deprecated)]
17970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17971 where
17972 S: serde::Serializer,
17973 {
17974 use serde::ser::SerializeStruct;
17975 let mut len = 0;
17976 if self.payload.is_some() {
17977 len += 1;
17978 }
17979 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
17980 if let Some(v) = self.payload.as_ref() {
17981 match v {
17982 version_update_payload::Payload::VersionDeltas(v) => {
17983 struct_ser.serialize_field("versionDeltas", v)?;
17984 }
17985 version_update_payload::Payload::PinnedVersion(v) => {
17986 struct_ser.serialize_field("pinnedVersion", v)?;
17987 }
17988 }
17989 }
17990 struct_ser.end()
17991 }
17992}
17993impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
17994 #[allow(deprecated)]
17995 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17996 where
17997 D: serde::Deserializer<'de>,
17998 {
17999 const FIELDS: &[&str] = &[
18000 "version_deltas",
18001 "versionDeltas",
18002 "pinned_version",
18003 "pinnedVersion",
18004 ];
18005
18006 #[allow(clippy::enum_variant_names)]
18007 enum GeneratedField {
18008 VersionDeltas,
18009 PinnedVersion,
18010 }
18011 impl<'de> serde::Deserialize<'de> for GeneratedField {
18012 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18013 where
18014 D: serde::Deserializer<'de>,
18015 {
18016 struct GeneratedVisitor;
18017
18018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18019 type Value = GeneratedField;
18020
18021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18022 write!(formatter, "expected one of: {:?}", &FIELDS)
18023 }
18024
18025 #[allow(unused_variables)]
18026 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18027 where
18028 E: serde::de::Error,
18029 {
18030 match value {
18031 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
18032 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
18033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18034 }
18035 }
18036 }
18037 deserializer.deserialize_identifier(GeneratedVisitor)
18038 }
18039 }
18040 struct GeneratedVisitor;
18041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18042 type Value = VersionUpdatePayload;
18043
18044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18045 formatter.write_str("struct hummock.VersionUpdatePayload")
18046 }
18047
18048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
18049 where
18050 V: serde::de::MapAccess<'de>,
18051 {
18052 let mut payload__ = None;
18053 while let Some(k) = map_.next_key()? {
18054 match k {
18055 GeneratedField::VersionDeltas => {
18056 if payload__.is_some() {
18057 return Err(serde::de::Error::duplicate_field("versionDeltas"));
18058 }
18059 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
18060;
18061 }
18062 GeneratedField::PinnedVersion => {
18063 if payload__.is_some() {
18064 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
18065 }
18066 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
18067;
18068 }
18069 }
18070 }
18071 Ok(VersionUpdatePayload {
18072 payload: payload__,
18073 })
18074 }
18075 }
18076 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
18077 }
18078}
18079impl serde::Serialize for VnodeWatermark {
18080 #[allow(deprecated)]
18081 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18082 where
18083 S: serde::Serializer,
18084 {
18085 use serde::ser::SerializeStruct;
18086 let mut len = 0;
18087 if !self.watermark.is_empty() {
18088 len += 1;
18089 }
18090 if self.vnode_bitmap.is_some() {
18091 len += 1;
18092 }
18093 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
18094 if !self.watermark.is_empty() {
18095 #[allow(clippy::needless_borrow)]
18096 #[allow(clippy::needless_borrows_for_generic_args)]
18097 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
18098 }
18099 if let Some(v) = self.vnode_bitmap.as_ref() {
18100 struct_ser.serialize_field("vnodeBitmap", v)?;
18101 }
18102 struct_ser.end()
18103 }
18104}
18105impl<'de> serde::Deserialize<'de> for VnodeWatermark {
18106 #[allow(deprecated)]
18107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18108 where
18109 D: serde::Deserializer<'de>,
18110 {
18111 const FIELDS: &[&str] = &[
18112 "watermark",
18113 "vnode_bitmap",
18114 "vnodeBitmap",
18115 ];
18116
18117 #[allow(clippy::enum_variant_names)]
18118 enum GeneratedField {
18119 Watermark,
18120 VnodeBitmap,
18121 }
18122 impl<'de> serde::Deserialize<'de> for GeneratedField {
18123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18124 where
18125 D: serde::Deserializer<'de>,
18126 {
18127 struct GeneratedVisitor;
18128
18129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18130 type Value = GeneratedField;
18131
18132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18133 write!(formatter, "expected one of: {:?}", &FIELDS)
18134 }
18135
18136 #[allow(unused_variables)]
18137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18138 where
18139 E: serde::de::Error,
18140 {
18141 match value {
18142 "watermark" => Ok(GeneratedField::Watermark),
18143 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
18144 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18145 }
18146 }
18147 }
18148 deserializer.deserialize_identifier(GeneratedVisitor)
18149 }
18150 }
18151 struct GeneratedVisitor;
18152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18153 type Value = VnodeWatermark;
18154
18155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18156 formatter.write_str("struct hummock.VnodeWatermark")
18157 }
18158
18159 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
18160 where
18161 V: serde::de::MapAccess<'de>,
18162 {
18163 let mut watermark__ = None;
18164 let mut vnode_bitmap__ = None;
18165 while let Some(k) = map_.next_key()? {
18166 match k {
18167 GeneratedField::Watermark => {
18168 if watermark__.is_some() {
18169 return Err(serde::de::Error::duplicate_field("watermark"));
18170 }
18171 watermark__ =
18172 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
18173 ;
18174 }
18175 GeneratedField::VnodeBitmap => {
18176 if vnode_bitmap__.is_some() {
18177 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
18178 }
18179 vnode_bitmap__ = map_.next_value()?;
18180 }
18181 }
18182 }
18183 Ok(VnodeWatermark {
18184 watermark: watermark__.unwrap_or_default(),
18185 vnode_bitmap: vnode_bitmap__,
18186 })
18187 }
18188 }
18189 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
18190 }
18191}
18192impl serde::Serialize for WriteLimits {
18193 #[allow(deprecated)]
18194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18195 where
18196 S: serde::Serializer,
18197 {
18198 use serde::ser::SerializeStruct;
18199 let mut len = 0;
18200 if !self.write_limits.is_empty() {
18201 len += 1;
18202 }
18203 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
18204 if !self.write_limits.is_empty() {
18205 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
18206 }
18207 struct_ser.end()
18208 }
18209}
18210impl<'de> serde::Deserialize<'de> for WriteLimits {
18211 #[allow(deprecated)]
18212 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18213 where
18214 D: serde::Deserializer<'de>,
18215 {
18216 const FIELDS: &[&str] = &[
18217 "write_limits",
18218 "writeLimits",
18219 ];
18220
18221 #[allow(clippy::enum_variant_names)]
18222 enum GeneratedField {
18223 WriteLimits,
18224 }
18225 impl<'de> serde::Deserialize<'de> for GeneratedField {
18226 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18227 where
18228 D: serde::Deserializer<'de>,
18229 {
18230 struct GeneratedVisitor;
18231
18232 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18233 type Value = GeneratedField;
18234
18235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18236 write!(formatter, "expected one of: {:?}", &FIELDS)
18237 }
18238
18239 #[allow(unused_variables)]
18240 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18241 where
18242 E: serde::de::Error,
18243 {
18244 match value {
18245 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
18246 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18247 }
18248 }
18249 }
18250 deserializer.deserialize_identifier(GeneratedVisitor)
18251 }
18252 }
18253 struct GeneratedVisitor;
18254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18255 type Value = WriteLimits;
18256
18257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18258 formatter.write_str("struct hummock.WriteLimits")
18259 }
18260
18261 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
18262 where
18263 V: serde::de::MapAccess<'de>,
18264 {
18265 let mut write_limits__ = None;
18266 while let Some(k) = map_.next_key()? {
18267 match k {
18268 GeneratedField::WriteLimits => {
18269 if write_limits__.is_some() {
18270 return Err(serde::de::Error::duplicate_field("writeLimits"));
18271 }
18272 write_limits__ = Some(
18273 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
18274 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18275 );
18276 }
18277 }
18278 }
18279 Ok(WriteLimits {
18280 write_limits: write_limits__.unwrap_or_default(),
18281 })
18282 }
18283 }
18284 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
18285 }
18286}
18287impl serde::Serialize for write_limits::WriteLimit {
18288 #[allow(deprecated)]
18289 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18290 where
18291 S: serde::Serializer,
18292 {
18293 use serde::ser::SerializeStruct;
18294 let mut len = 0;
18295 if !self.table_ids.is_empty() {
18296 len += 1;
18297 }
18298 if !self.reason.is_empty() {
18299 len += 1;
18300 }
18301 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
18302 if !self.table_ids.is_empty() {
18303 struct_ser.serialize_field("tableIds", &self.table_ids)?;
18304 }
18305 if !self.reason.is_empty() {
18306 struct_ser.serialize_field("reason", &self.reason)?;
18307 }
18308 struct_ser.end()
18309 }
18310}
18311impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
18312 #[allow(deprecated)]
18313 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18314 where
18315 D: serde::Deserializer<'de>,
18316 {
18317 const FIELDS: &[&str] = &[
18318 "table_ids",
18319 "tableIds",
18320 "reason",
18321 ];
18322
18323 #[allow(clippy::enum_variant_names)]
18324 enum GeneratedField {
18325 TableIds,
18326 Reason,
18327 }
18328 impl<'de> serde::Deserialize<'de> for GeneratedField {
18329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18330 where
18331 D: serde::Deserializer<'de>,
18332 {
18333 struct GeneratedVisitor;
18334
18335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18336 type Value = GeneratedField;
18337
18338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18339 write!(formatter, "expected one of: {:?}", &FIELDS)
18340 }
18341
18342 #[allow(unused_variables)]
18343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18344 where
18345 E: serde::de::Error,
18346 {
18347 match value {
18348 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
18349 "reason" => Ok(GeneratedField::Reason),
18350 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18351 }
18352 }
18353 }
18354 deserializer.deserialize_identifier(GeneratedVisitor)
18355 }
18356 }
18357 struct GeneratedVisitor;
18358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18359 type Value = write_limits::WriteLimit;
18360
18361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18362 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
18363 }
18364
18365 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
18366 where
18367 V: serde::de::MapAccess<'de>,
18368 {
18369 let mut table_ids__ = None;
18370 let mut reason__ = None;
18371 while let Some(k) = map_.next_key()? {
18372 match k {
18373 GeneratedField::TableIds => {
18374 if table_ids__.is_some() {
18375 return Err(serde::de::Error::duplicate_field("tableIds"));
18376 }
18377 table_ids__ =
18378 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18379 .into_iter().map(|x| x.0).collect())
18380 ;
18381 }
18382 GeneratedField::Reason => {
18383 if reason__.is_some() {
18384 return Err(serde::de::Error::duplicate_field("reason"));
18385 }
18386 reason__ = Some(map_.next_value()?);
18387 }
18388 }
18389 }
18390 Ok(write_limits::WriteLimit {
18391 table_ids: table_ids__.unwrap_or_default(),
18392 reason: reason__.unwrap_or_default(),
18393 })
18394 }
18395 }
18396 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
18397 }
18398}