1use crate::hummock::*;
2impl serde::Serialize for BloomFilterType {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 let variant = match self {
9 Self::BloomFilterUnspecified => "BLOOM_FILTER_UNSPECIFIED",
10 Self::Sstable => "SSTABLE",
11 Self::Blocked => "BLOCKED",
12 };
13 serializer.serialize_str(variant)
14 }
15}
16impl<'de> serde::Deserialize<'de> for BloomFilterType {
17 #[allow(deprecated)]
18 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19 where
20 D: serde::Deserializer<'de>,
21 {
22 const FIELDS: &[&str] = &[
23 "BLOOM_FILTER_UNSPECIFIED",
24 "SSTABLE",
25 "BLOCKED",
26 ];
27
28 struct GeneratedVisitor;
29
30 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
31 type Value = BloomFilterType;
32
33 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34 write!(formatter, "expected one of: {:?}", &FIELDS)
35 }
36
37 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
38 where
39 E: serde::de::Error,
40 {
41 i32::try_from(v)
42 .ok()
43 .and_then(|x| x.try_into().ok())
44 .ok_or_else(|| {
45 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
46 })
47 }
48
49 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
50 where
51 E: serde::de::Error,
52 {
53 i32::try_from(v)
54 .ok()
55 .and_then(|x| x.try_into().ok())
56 .ok_or_else(|| {
57 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
58 })
59 }
60
61 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
62 where
63 E: serde::de::Error,
64 {
65 match value {
66 "BLOOM_FILTER_UNSPECIFIED" => Ok(BloomFilterType::BloomFilterUnspecified),
67 "SSTABLE" => Ok(BloomFilterType::Sstable),
68 "BLOCKED" => Ok(BloomFilterType::Blocked),
69 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
70 }
71 }
72 }
73 deserializer.deserialize_any(GeneratedVisitor)
74 }
75}
76impl serde::Serialize for BranchedObject {
77 #[allow(deprecated)]
78 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
79 where
80 S: serde::Serializer,
81 {
82 use serde::ser::SerializeStruct;
83 let mut len = 0;
84 if self.object_id != 0 {
85 len += 1;
86 }
87 if !self.sst_id.is_empty() {
88 len += 1;
89 }
90 if self.compaction_group_id != 0 {
91 len += 1;
92 }
93 let mut struct_ser = serializer.serialize_struct("hummock.BranchedObject", len)?;
94 if self.object_id != 0 {
95 #[allow(clippy::needless_borrow)]
96 #[allow(clippy::needless_borrows_for_generic_args)]
97 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
98 }
99 if !self.sst_id.is_empty() {
100 struct_ser.serialize_field("sstId", &self.sst_id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
101 }
102 if self.compaction_group_id != 0 {
103 #[allow(clippy::needless_borrow)]
104 #[allow(clippy::needless_borrows_for_generic_args)]
105 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
106 }
107 struct_ser.end()
108 }
109}
110impl<'de> serde::Deserialize<'de> for BranchedObject {
111 #[allow(deprecated)]
112 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
113 where
114 D: serde::Deserializer<'de>,
115 {
116 const FIELDS: &[&str] = &[
117 "object_id",
118 "objectId",
119 "sst_id",
120 "sstId",
121 "compaction_group_id",
122 "compactionGroupId",
123 ];
124
125 #[allow(clippy::enum_variant_names)]
126 enum GeneratedField {
127 ObjectId,
128 SstId,
129 CompactionGroupId,
130 }
131 impl<'de> serde::Deserialize<'de> for GeneratedField {
132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
133 where
134 D: serde::Deserializer<'de>,
135 {
136 struct GeneratedVisitor;
137
138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
139 type Value = GeneratedField;
140
141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
142 write!(formatter, "expected one of: {:?}", &FIELDS)
143 }
144
145 #[allow(unused_variables)]
146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
147 where
148 E: serde::de::Error,
149 {
150 match value {
151 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
152 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
153 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
155 }
156 }
157 }
158 deserializer.deserialize_identifier(GeneratedVisitor)
159 }
160 }
161 struct GeneratedVisitor;
162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
163 type Value = BranchedObject;
164
165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
166 formatter.write_str("struct hummock.BranchedObject")
167 }
168
169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BranchedObject, V::Error>
170 where
171 V: serde::de::MapAccess<'de>,
172 {
173 let mut object_id__ = None;
174 let mut sst_id__ = None;
175 let mut compaction_group_id__ = None;
176 while let Some(k) = map_.next_key()? {
177 match k {
178 GeneratedField::ObjectId => {
179 if object_id__.is_some() {
180 return Err(serde::de::Error::duplicate_field("objectId"));
181 }
182 object_id__ =
183 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
184 ;
185 }
186 GeneratedField::SstId => {
187 if sst_id__.is_some() {
188 return Err(serde::de::Error::duplicate_field("sstId"));
189 }
190 sst_id__ =
191 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
192 .into_iter().map(|x| x.0).collect())
193 ;
194 }
195 GeneratedField::CompactionGroupId => {
196 if compaction_group_id__.is_some() {
197 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
198 }
199 compaction_group_id__ =
200 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
201 ;
202 }
203 }
204 }
205 Ok(BranchedObject {
206 object_id: object_id__.unwrap_or_default(),
207 sst_id: sst_id__.unwrap_or_default(),
208 compaction_group_id: compaction_group_id__.unwrap_or_default(),
209 })
210 }
211 }
212 deserializer.deserialize_struct("hummock.BranchedObject", FIELDS, GeneratedVisitor)
213 }
214}
215impl serde::Serialize for CancelCompactTask {
216 #[allow(deprecated)]
217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
218 where
219 S: serde::Serializer,
220 {
221 use serde::ser::SerializeStruct;
222 let mut len = 0;
223 if self.context_id != 0 {
224 len += 1;
225 }
226 if self.task_id != 0 {
227 len += 1;
228 }
229 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTask", len)?;
230 if self.context_id != 0 {
231 struct_ser.serialize_field("contextId", &self.context_id)?;
232 }
233 if self.task_id != 0 {
234 #[allow(clippy::needless_borrow)]
235 #[allow(clippy::needless_borrows_for_generic_args)]
236 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
237 }
238 struct_ser.end()
239 }
240}
241impl<'de> serde::Deserialize<'de> for CancelCompactTask {
242 #[allow(deprecated)]
243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
244 where
245 D: serde::Deserializer<'de>,
246 {
247 const FIELDS: &[&str] = &[
248 "context_id",
249 "contextId",
250 "task_id",
251 "taskId",
252 ];
253
254 #[allow(clippy::enum_variant_names)]
255 enum GeneratedField {
256 ContextId,
257 TaskId,
258 }
259 impl<'de> serde::Deserialize<'de> for GeneratedField {
260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
261 where
262 D: serde::Deserializer<'de>,
263 {
264 struct GeneratedVisitor;
265
266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
267 type Value = GeneratedField;
268
269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270 write!(formatter, "expected one of: {:?}", &FIELDS)
271 }
272
273 #[allow(unused_variables)]
274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
275 where
276 E: serde::de::Error,
277 {
278 match value {
279 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
280 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
282 }
283 }
284 }
285 deserializer.deserialize_identifier(GeneratedVisitor)
286 }
287 }
288 struct GeneratedVisitor;
289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
290 type Value = CancelCompactTask;
291
292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
293 formatter.write_str("struct hummock.CancelCompactTask")
294 }
295
296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTask, V::Error>
297 where
298 V: serde::de::MapAccess<'de>,
299 {
300 let mut context_id__ = None;
301 let mut task_id__ = None;
302 while let Some(k) = map_.next_key()? {
303 match k {
304 GeneratedField::ContextId => {
305 if context_id__.is_some() {
306 return Err(serde::de::Error::duplicate_field("contextId"));
307 }
308 context_id__ =
309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
310 ;
311 }
312 GeneratedField::TaskId => {
313 if task_id__.is_some() {
314 return Err(serde::de::Error::duplicate_field("taskId"));
315 }
316 task_id__ =
317 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
318 ;
319 }
320 }
321 }
322 Ok(CancelCompactTask {
323 context_id: context_id__.unwrap_or_default(),
324 task_id: task_id__.unwrap_or_default(),
325 })
326 }
327 }
328 deserializer.deserialize_struct("hummock.CancelCompactTask", FIELDS, GeneratedVisitor)
329 }
330}
331impl serde::Serialize for CancelCompactTaskRequest {
332 #[allow(deprecated)]
333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
334 where
335 S: serde::Serializer,
336 {
337 use serde::ser::SerializeStruct;
338 let mut len = 0;
339 if self.task_id != 0 {
340 len += 1;
341 }
342 if self.task_status != 0 {
343 len += 1;
344 }
345 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskRequest", len)?;
346 if self.task_id != 0 {
347 #[allow(clippy::needless_borrow)]
348 #[allow(clippy::needless_borrows_for_generic_args)]
349 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
350 }
351 if self.task_status != 0 {
352 let v = compact_task::TaskStatus::try_from(self.task_status)
353 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
354 struct_ser.serialize_field("taskStatus", &v)?;
355 }
356 struct_ser.end()
357 }
358}
359impl<'de> serde::Deserialize<'de> for CancelCompactTaskRequest {
360 #[allow(deprecated)]
361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
362 where
363 D: serde::Deserializer<'de>,
364 {
365 const FIELDS: &[&str] = &[
366 "task_id",
367 "taskId",
368 "task_status",
369 "taskStatus",
370 ];
371
372 #[allow(clippy::enum_variant_names)]
373 enum GeneratedField {
374 TaskId,
375 TaskStatus,
376 }
377 impl<'de> serde::Deserialize<'de> for GeneratedField {
378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
379 where
380 D: serde::Deserializer<'de>,
381 {
382 struct GeneratedVisitor;
383
384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
385 type Value = GeneratedField;
386
387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
388 write!(formatter, "expected one of: {:?}", &FIELDS)
389 }
390
391 #[allow(unused_variables)]
392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
393 where
394 E: serde::de::Error,
395 {
396 match value {
397 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
398 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
400 }
401 }
402 }
403 deserializer.deserialize_identifier(GeneratedVisitor)
404 }
405 }
406 struct GeneratedVisitor;
407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
408 type Value = CancelCompactTaskRequest;
409
410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
411 formatter.write_str("struct hummock.CancelCompactTaskRequest")
412 }
413
414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskRequest, V::Error>
415 where
416 V: serde::de::MapAccess<'de>,
417 {
418 let mut task_id__ = None;
419 let mut task_status__ = None;
420 while let Some(k) = map_.next_key()? {
421 match k {
422 GeneratedField::TaskId => {
423 if task_id__.is_some() {
424 return Err(serde::de::Error::duplicate_field("taskId"));
425 }
426 task_id__ =
427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
428 ;
429 }
430 GeneratedField::TaskStatus => {
431 if task_status__.is_some() {
432 return Err(serde::de::Error::duplicate_field("taskStatus"));
433 }
434 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
435 }
436 }
437 }
438 Ok(CancelCompactTaskRequest {
439 task_id: task_id__.unwrap_or_default(),
440 task_status: task_status__.unwrap_or_default(),
441 })
442 }
443 }
444 deserializer.deserialize_struct("hummock.CancelCompactTaskRequest", FIELDS, GeneratedVisitor)
445 }
446}
447impl serde::Serialize for CancelCompactTaskResponse {
448 #[allow(deprecated)]
449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
450 where
451 S: serde::Serializer,
452 {
453 use serde::ser::SerializeStruct;
454 let mut len = 0;
455 if self.ret {
456 len += 1;
457 }
458 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskResponse", len)?;
459 if self.ret {
460 struct_ser.serialize_field("ret", &self.ret)?;
461 }
462 struct_ser.end()
463 }
464}
465impl<'de> serde::Deserialize<'de> for CancelCompactTaskResponse {
466 #[allow(deprecated)]
467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
468 where
469 D: serde::Deserializer<'de>,
470 {
471 const FIELDS: &[&str] = &[
472 "ret",
473 ];
474
475 #[allow(clippy::enum_variant_names)]
476 enum GeneratedField {
477 Ret,
478 }
479 impl<'de> serde::Deserialize<'de> for GeneratedField {
480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
481 where
482 D: serde::Deserializer<'de>,
483 {
484 struct GeneratedVisitor;
485
486 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
487 type Value = GeneratedField;
488
489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
490 write!(formatter, "expected one of: {:?}", &FIELDS)
491 }
492
493 #[allow(unused_variables)]
494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
495 where
496 E: serde::de::Error,
497 {
498 match value {
499 "ret" => Ok(GeneratedField::Ret),
500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
501 }
502 }
503 }
504 deserializer.deserialize_identifier(GeneratedVisitor)
505 }
506 }
507 struct GeneratedVisitor;
508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
509 type Value = CancelCompactTaskResponse;
510
511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
512 formatter.write_str("struct hummock.CancelCompactTaskResponse")
513 }
514
515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskResponse, V::Error>
516 where
517 V: serde::de::MapAccess<'de>,
518 {
519 let mut ret__ = None;
520 while let Some(k) = map_.next_key()? {
521 match k {
522 GeneratedField::Ret => {
523 if ret__.is_some() {
524 return Err(serde::de::Error::duplicate_field("ret"));
525 }
526 ret__ = Some(map_.next_value()?);
527 }
528 }
529 }
530 Ok(CancelCompactTaskResponse {
531 ret: ret__.unwrap_or_default(),
532 })
533 }
534 }
535 deserializer.deserialize_struct("hummock.CancelCompactTaskResponse", FIELDS, GeneratedVisitor)
536 }
537}
538impl serde::Serialize for CompactStatus {
539 #[allow(deprecated)]
540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
541 where
542 S: serde::Serializer,
543 {
544 use serde::ser::SerializeStruct;
545 let mut len = 0;
546 if self.compaction_group_id != 0 {
547 len += 1;
548 }
549 if !self.level_handlers.is_empty() {
550 len += 1;
551 }
552 let mut struct_ser = serializer.serialize_struct("hummock.CompactStatus", len)?;
553 if self.compaction_group_id != 0 {
554 #[allow(clippy::needless_borrow)]
555 #[allow(clippy::needless_borrows_for_generic_args)]
556 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
557 }
558 if !self.level_handlers.is_empty() {
559 struct_ser.serialize_field("levelHandlers", &self.level_handlers)?;
560 }
561 struct_ser.end()
562 }
563}
564impl<'de> serde::Deserialize<'de> for CompactStatus {
565 #[allow(deprecated)]
566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
567 where
568 D: serde::Deserializer<'de>,
569 {
570 const FIELDS: &[&str] = &[
571 "compaction_group_id",
572 "compactionGroupId",
573 "level_handlers",
574 "levelHandlers",
575 ];
576
577 #[allow(clippy::enum_variant_names)]
578 enum GeneratedField {
579 CompactionGroupId,
580 LevelHandlers,
581 }
582 impl<'de> serde::Deserialize<'de> for GeneratedField {
583 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
584 where
585 D: serde::Deserializer<'de>,
586 {
587 struct GeneratedVisitor;
588
589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
590 type Value = GeneratedField;
591
592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
593 write!(formatter, "expected one of: {:?}", &FIELDS)
594 }
595
596 #[allow(unused_variables)]
597 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
598 where
599 E: serde::de::Error,
600 {
601 match value {
602 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
603 "levelHandlers" | "level_handlers" => Ok(GeneratedField::LevelHandlers),
604 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
605 }
606 }
607 }
608 deserializer.deserialize_identifier(GeneratedVisitor)
609 }
610 }
611 struct GeneratedVisitor;
612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
613 type Value = CompactStatus;
614
615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
616 formatter.write_str("struct hummock.CompactStatus")
617 }
618
619 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactStatus, V::Error>
620 where
621 V: serde::de::MapAccess<'de>,
622 {
623 let mut compaction_group_id__ = None;
624 let mut level_handlers__ = None;
625 while let Some(k) = map_.next_key()? {
626 match k {
627 GeneratedField::CompactionGroupId => {
628 if compaction_group_id__.is_some() {
629 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
630 }
631 compaction_group_id__ =
632 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
633 ;
634 }
635 GeneratedField::LevelHandlers => {
636 if level_handlers__.is_some() {
637 return Err(serde::de::Error::duplicate_field("levelHandlers"));
638 }
639 level_handlers__ = Some(map_.next_value()?);
640 }
641 }
642 }
643 Ok(CompactStatus {
644 compaction_group_id: compaction_group_id__.unwrap_or_default(),
645 level_handlers: level_handlers__.unwrap_or_default(),
646 })
647 }
648 }
649 deserializer.deserialize_struct("hummock.CompactStatus", FIELDS, GeneratedVisitor)
650 }
651}
652impl serde::Serialize for CompactTask {
653 #[allow(deprecated)]
654 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
655 where
656 S: serde::Serializer,
657 {
658 use serde::ser::SerializeStruct;
659 let mut len = 0;
660 if !self.input_ssts.is_empty() {
661 len += 1;
662 }
663 if !self.splits.is_empty() {
664 len += 1;
665 }
666 if !self.sorted_output_ssts.is_empty() {
667 len += 1;
668 }
669 if self.task_id != 0 {
670 len += 1;
671 }
672 if self.target_level != 0 {
673 len += 1;
674 }
675 if self.gc_delete_keys {
676 len += 1;
677 }
678 if self.base_level != 0 {
679 len += 1;
680 }
681 if self.task_status != 0 {
682 len += 1;
683 }
684 if self.compaction_group_id != 0 {
685 len += 1;
686 }
687 if !self.existing_table_ids.is_empty() {
688 len += 1;
689 }
690 if self.compression_algorithm != 0 {
691 len += 1;
692 }
693 if self.target_file_size != 0 {
694 len += 1;
695 }
696 if self.compaction_filter_mask != 0 {
697 len += 1;
698 }
699 if !self.table_options.is_empty() {
700 len += 1;
701 }
702 if self.current_epoch_time != 0 {
703 len += 1;
704 }
705 if self.target_sub_level_id != 0 {
706 len += 1;
707 }
708 if self.task_type != 0 {
709 len += 1;
710 }
711 if self.split_by_state_table {
712 len += 1;
713 }
714 if self.split_weight_by_vnode != 0 {
715 len += 1;
716 }
717 if !self.table_vnode_partition.is_empty() {
718 len += 1;
719 }
720 if !self.table_watermarks.is_empty() {
721 len += 1;
722 }
723 if !self.table_schemas.is_empty() {
724 len += 1;
725 }
726 if self.max_sub_compaction != 0 {
727 len += 1;
728 }
729 if self.compaction_group_version_id != 0 {
730 len += 1;
731 }
732 let mut struct_ser = serializer.serialize_struct("hummock.CompactTask", len)?;
733 if !self.input_ssts.is_empty() {
734 struct_ser.serialize_field("inputSsts", &self.input_ssts)?;
735 }
736 if !self.splits.is_empty() {
737 struct_ser.serialize_field("splits", &self.splits)?;
738 }
739 if !self.sorted_output_ssts.is_empty() {
740 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
741 }
742 if self.task_id != 0 {
743 #[allow(clippy::needless_borrow)]
744 #[allow(clippy::needless_borrows_for_generic_args)]
745 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
746 }
747 if self.target_level != 0 {
748 struct_ser.serialize_field("targetLevel", &self.target_level)?;
749 }
750 if self.gc_delete_keys {
751 struct_ser.serialize_field("gcDeleteKeys", &self.gc_delete_keys)?;
752 }
753 if self.base_level != 0 {
754 struct_ser.serialize_field("baseLevel", &self.base_level)?;
755 }
756 if self.task_status != 0 {
757 let v = compact_task::TaskStatus::try_from(self.task_status)
758 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
759 struct_ser.serialize_field("taskStatus", &v)?;
760 }
761 if self.compaction_group_id != 0 {
762 #[allow(clippy::needless_borrow)]
763 #[allow(clippy::needless_borrows_for_generic_args)]
764 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
765 }
766 if !self.existing_table_ids.is_empty() {
767 struct_ser.serialize_field("existingTableIds", &self.existing_table_ids)?;
768 }
769 if self.compression_algorithm != 0 {
770 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
771 }
772 if self.target_file_size != 0 {
773 #[allow(clippy::needless_borrow)]
774 #[allow(clippy::needless_borrows_for_generic_args)]
775 struct_ser.serialize_field("targetFileSize", ToString::to_string(&self.target_file_size).as_str())?;
776 }
777 if self.compaction_filter_mask != 0 {
778 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
779 }
780 if !self.table_options.is_empty() {
781 struct_ser.serialize_field("tableOptions", &self.table_options)?;
782 }
783 if self.current_epoch_time != 0 {
784 #[allow(clippy::needless_borrow)]
785 #[allow(clippy::needless_borrows_for_generic_args)]
786 struct_ser.serialize_field("currentEpochTime", ToString::to_string(&self.current_epoch_time).as_str())?;
787 }
788 if self.target_sub_level_id != 0 {
789 #[allow(clippy::needless_borrow)]
790 #[allow(clippy::needless_borrows_for_generic_args)]
791 struct_ser.serialize_field("targetSubLevelId", ToString::to_string(&self.target_sub_level_id).as_str())?;
792 }
793 if self.task_type != 0 {
794 let v = compact_task::TaskType::try_from(self.task_type)
795 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_type)))?;
796 struct_ser.serialize_field("taskType", &v)?;
797 }
798 if self.split_by_state_table {
799 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
800 }
801 if self.split_weight_by_vnode != 0 {
802 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
803 }
804 if !self.table_vnode_partition.is_empty() {
805 struct_ser.serialize_field("tableVnodePartition", &self.table_vnode_partition)?;
806 }
807 if !self.table_watermarks.is_empty() {
808 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
809 }
810 if !self.table_schemas.is_empty() {
811 struct_ser.serialize_field("tableSchemas", &self.table_schemas)?;
812 }
813 if self.max_sub_compaction != 0 {
814 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
815 }
816 if self.compaction_group_version_id != 0 {
817 #[allow(clippy::needless_borrow)]
818 #[allow(clippy::needless_borrows_for_generic_args)]
819 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
820 }
821 struct_ser.end()
822 }
823}
824impl<'de> serde::Deserialize<'de> for CompactTask {
825 #[allow(deprecated)]
826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
827 where
828 D: serde::Deserializer<'de>,
829 {
830 const FIELDS: &[&str] = &[
831 "input_ssts",
832 "inputSsts",
833 "splits",
834 "sorted_output_ssts",
835 "sortedOutputSsts",
836 "task_id",
837 "taskId",
838 "target_level",
839 "targetLevel",
840 "gc_delete_keys",
841 "gcDeleteKeys",
842 "base_level",
843 "baseLevel",
844 "task_status",
845 "taskStatus",
846 "compaction_group_id",
847 "compactionGroupId",
848 "existing_table_ids",
849 "existingTableIds",
850 "compression_algorithm",
851 "compressionAlgorithm",
852 "target_file_size",
853 "targetFileSize",
854 "compaction_filter_mask",
855 "compactionFilterMask",
856 "table_options",
857 "tableOptions",
858 "current_epoch_time",
859 "currentEpochTime",
860 "target_sub_level_id",
861 "targetSubLevelId",
862 "task_type",
863 "taskType",
864 "split_by_state_table",
865 "splitByStateTable",
866 "split_weight_by_vnode",
867 "splitWeightByVnode",
868 "table_vnode_partition",
869 "tableVnodePartition",
870 "table_watermarks",
871 "tableWatermarks",
872 "table_schemas",
873 "tableSchemas",
874 "max_sub_compaction",
875 "maxSubCompaction",
876 "compaction_group_version_id",
877 "compactionGroupVersionId",
878 ];
879
880 #[allow(clippy::enum_variant_names)]
881 enum GeneratedField {
882 InputSsts,
883 Splits,
884 SortedOutputSsts,
885 TaskId,
886 TargetLevel,
887 GcDeleteKeys,
888 BaseLevel,
889 TaskStatus,
890 CompactionGroupId,
891 ExistingTableIds,
892 CompressionAlgorithm,
893 TargetFileSize,
894 CompactionFilterMask,
895 TableOptions,
896 CurrentEpochTime,
897 TargetSubLevelId,
898 TaskType,
899 SplitByStateTable,
900 SplitWeightByVnode,
901 TableVnodePartition,
902 TableWatermarks,
903 TableSchemas,
904 MaxSubCompaction,
905 CompactionGroupVersionId,
906 }
907 impl<'de> serde::Deserialize<'de> for GeneratedField {
908 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
909 where
910 D: serde::Deserializer<'de>,
911 {
912 struct GeneratedVisitor;
913
914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
915 type Value = GeneratedField;
916
917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
918 write!(formatter, "expected one of: {:?}", &FIELDS)
919 }
920
921 #[allow(unused_variables)]
922 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
923 where
924 E: serde::de::Error,
925 {
926 match value {
927 "inputSsts" | "input_ssts" => Ok(GeneratedField::InputSsts),
928 "splits" => Ok(GeneratedField::Splits),
929 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
930 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
931 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
932 "gcDeleteKeys" | "gc_delete_keys" => Ok(GeneratedField::GcDeleteKeys),
933 "baseLevel" | "base_level" => Ok(GeneratedField::BaseLevel),
934 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
935 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
936 "existingTableIds" | "existing_table_ids" => Ok(GeneratedField::ExistingTableIds),
937 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
938 "targetFileSize" | "target_file_size" => Ok(GeneratedField::TargetFileSize),
939 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
940 "tableOptions" | "table_options" => Ok(GeneratedField::TableOptions),
941 "currentEpochTime" | "current_epoch_time" => Ok(GeneratedField::CurrentEpochTime),
942 "targetSubLevelId" | "target_sub_level_id" => Ok(GeneratedField::TargetSubLevelId),
943 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
944 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
945 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
946 "tableVnodePartition" | "table_vnode_partition" => Ok(GeneratedField::TableVnodePartition),
947 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
948 "tableSchemas" | "table_schemas" => Ok(GeneratedField::TableSchemas),
949 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
950 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
952 }
953 }
954 }
955 deserializer.deserialize_identifier(GeneratedVisitor)
956 }
957 }
958 struct GeneratedVisitor;
959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
960 type Value = CompactTask;
961
962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
963 formatter.write_str("struct hummock.CompactTask")
964 }
965
966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTask, V::Error>
967 where
968 V: serde::de::MapAccess<'de>,
969 {
970 let mut input_ssts__ = None;
971 let mut splits__ = None;
972 let mut sorted_output_ssts__ = None;
973 let mut task_id__ = None;
974 let mut target_level__ = None;
975 let mut gc_delete_keys__ = None;
976 let mut base_level__ = None;
977 let mut task_status__ = None;
978 let mut compaction_group_id__ = None;
979 let mut existing_table_ids__ = None;
980 let mut compression_algorithm__ = None;
981 let mut target_file_size__ = None;
982 let mut compaction_filter_mask__ = None;
983 let mut table_options__ = None;
984 let mut current_epoch_time__ = None;
985 let mut target_sub_level_id__ = None;
986 let mut task_type__ = None;
987 let mut split_by_state_table__ = None;
988 let mut split_weight_by_vnode__ = None;
989 let mut table_vnode_partition__ = None;
990 let mut table_watermarks__ = None;
991 let mut table_schemas__ = None;
992 let mut max_sub_compaction__ = None;
993 let mut compaction_group_version_id__ = None;
994 while let Some(k) = map_.next_key()? {
995 match k {
996 GeneratedField::InputSsts => {
997 if input_ssts__.is_some() {
998 return Err(serde::de::Error::duplicate_field("inputSsts"));
999 }
1000 input_ssts__ = Some(map_.next_value()?);
1001 }
1002 GeneratedField::Splits => {
1003 if splits__.is_some() {
1004 return Err(serde::de::Error::duplicate_field("splits"));
1005 }
1006 splits__ = Some(map_.next_value()?);
1007 }
1008 GeneratedField::SortedOutputSsts => {
1009 if sorted_output_ssts__.is_some() {
1010 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
1011 }
1012 sorted_output_ssts__ = Some(map_.next_value()?);
1013 }
1014 GeneratedField::TaskId => {
1015 if task_id__.is_some() {
1016 return Err(serde::de::Error::duplicate_field("taskId"));
1017 }
1018 task_id__ =
1019 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1020 ;
1021 }
1022 GeneratedField::TargetLevel => {
1023 if target_level__.is_some() {
1024 return Err(serde::de::Error::duplicate_field("targetLevel"));
1025 }
1026 target_level__ =
1027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1028 ;
1029 }
1030 GeneratedField::GcDeleteKeys => {
1031 if gc_delete_keys__.is_some() {
1032 return Err(serde::de::Error::duplicate_field("gcDeleteKeys"));
1033 }
1034 gc_delete_keys__ = Some(map_.next_value()?);
1035 }
1036 GeneratedField::BaseLevel => {
1037 if base_level__.is_some() {
1038 return Err(serde::de::Error::duplicate_field("baseLevel"));
1039 }
1040 base_level__ =
1041 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1042 ;
1043 }
1044 GeneratedField::TaskStatus => {
1045 if task_status__.is_some() {
1046 return Err(serde::de::Error::duplicate_field("taskStatus"));
1047 }
1048 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
1049 }
1050 GeneratedField::CompactionGroupId => {
1051 if compaction_group_id__.is_some() {
1052 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1053 }
1054 compaction_group_id__ =
1055 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1056 ;
1057 }
1058 GeneratedField::ExistingTableIds => {
1059 if existing_table_ids__.is_some() {
1060 return Err(serde::de::Error::duplicate_field("existingTableIds"));
1061 }
1062 existing_table_ids__ =
1063 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1064 .into_iter().map(|x| x.0).collect())
1065 ;
1066 }
1067 GeneratedField::CompressionAlgorithm => {
1068 if compression_algorithm__.is_some() {
1069 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
1070 }
1071 compression_algorithm__ =
1072 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1073 ;
1074 }
1075 GeneratedField::TargetFileSize => {
1076 if target_file_size__.is_some() {
1077 return Err(serde::de::Error::duplicate_field("targetFileSize"));
1078 }
1079 target_file_size__ =
1080 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1081 ;
1082 }
1083 GeneratedField::CompactionFilterMask => {
1084 if compaction_filter_mask__.is_some() {
1085 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
1086 }
1087 compaction_filter_mask__ =
1088 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1089 ;
1090 }
1091 GeneratedField::TableOptions => {
1092 if table_options__.is_some() {
1093 return Err(serde::de::Error::duplicate_field("tableOptions"));
1094 }
1095 table_options__ = Some(
1096 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1097 .into_iter().map(|(k,v)| (k.0, v)).collect()
1098 );
1099 }
1100 GeneratedField::CurrentEpochTime => {
1101 if current_epoch_time__.is_some() {
1102 return Err(serde::de::Error::duplicate_field("currentEpochTime"));
1103 }
1104 current_epoch_time__ =
1105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1106 ;
1107 }
1108 GeneratedField::TargetSubLevelId => {
1109 if target_sub_level_id__.is_some() {
1110 return Err(serde::de::Error::duplicate_field("targetSubLevelId"));
1111 }
1112 target_sub_level_id__ =
1113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1114 ;
1115 }
1116 GeneratedField::TaskType => {
1117 if task_type__.is_some() {
1118 return Err(serde::de::Error::duplicate_field("taskType"));
1119 }
1120 task_type__ = Some(map_.next_value::<compact_task::TaskType>()? as i32);
1121 }
1122 GeneratedField::SplitByStateTable => {
1123 if split_by_state_table__.is_some() {
1124 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
1125 }
1126 split_by_state_table__ = Some(map_.next_value()?);
1127 }
1128 GeneratedField::SplitWeightByVnode => {
1129 if split_weight_by_vnode__.is_some() {
1130 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
1131 }
1132 split_weight_by_vnode__ =
1133 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1134 ;
1135 }
1136 GeneratedField::TableVnodePartition => {
1137 if table_vnode_partition__.is_some() {
1138 return Err(serde::de::Error::duplicate_field("tableVnodePartition"));
1139 }
1140 table_vnode_partition__ = Some(
1141 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
1142 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
1143 );
1144 }
1145 GeneratedField::TableWatermarks => {
1146 if table_watermarks__.is_some() {
1147 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
1148 }
1149 table_watermarks__ = Some(
1150 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1151 .into_iter().map(|(k,v)| (k.0, v)).collect()
1152 );
1153 }
1154 GeneratedField::TableSchemas => {
1155 if table_schemas__.is_some() {
1156 return Err(serde::de::Error::duplicate_field("tableSchemas"));
1157 }
1158 table_schemas__ = Some(
1159 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1160 .into_iter().map(|(k,v)| (k.0, v)).collect()
1161 );
1162 }
1163 GeneratedField::MaxSubCompaction => {
1164 if max_sub_compaction__.is_some() {
1165 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
1166 }
1167 max_sub_compaction__ =
1168 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1169 ;
1170 }
1171 GeneratedField::CompactionGroupVersionId => {
1172 if compaction_group_version_id__.is_some() {
1173 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
1174 }
1175 compaction_group_version_id__ =
1176 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1177 ;
1178 }
1179 }
1180 }
1181 Ok(CompactTask {
1182 input_ssts: input_ssts__.unwrap_or_default(),
1183 splits: splits__.unwrap_or_default(),
1184 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
1185 task_id: task_id__.unwrap_or_default(),
1186 target_level: target_level__.unwrap_or_default(),
1187 gc_delete_keys: gc_delete_keys__.unwrap_or_default(),
1188 base_level: base_level__.unwrap_or_default(),
1189 task_status: task_status__.unwrap_or_default(),
1190 compaction_group_id: compaction_group_id__.unwrap_or_default(),
1191 existing_table_ids: existing_table_ids__.unwrap_or_default(),
1192 compression_algorithm: compression_algorithm__.unwrap_or_default(),
1193 target_file_size: target_file_size__.unwrap_or_default(),
1194 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
1195 table_options: table_options__.unwrap_or_default(),
1196 current_epoch_time: current_epoch_time__.unwrap_or_default(),
1197 target_sub_level_id: target_sub_level_id__.unwrap_or_default(),
1198 task_type: task_type__.unwrap_or_default(),
1199 split_by_state_table: split_by_state_table__.unwrap_or_default(),
1200 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
1201 table_vnode_partition: table_vnode_partition__.unwrap_or_default(),
1202 table_watermarks: table_watermarks__.unwrap_or_default(),
1203 table_schemas: table_schemas__.unwrap_or_default(),
1204 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
1205 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
1206 })
1207 }
1208 }
1209 deserializer.deserialize_struct("hummock.CompactTask", FIELDS, GeneratedVisitor)
1210 }
1211}
1212impl serde::Serialize for compact_task::TaskStatus {
1213 #[allow(deprecated)]
1214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1215 where
1216 S: serde::Serializer,
1217 {
1218 let variant = match self {
1219 Self::Unspecified => "UNSPECIFIED",
1220 Self::Pending => "PENDING",
1221 Self::Success => "SUCCESS",
1222 Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
1223 Self::NoAvailMemoryResourceCanceled => "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1224 Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
1225 Self::SendFailCanceled => "SEND_FAIL_CANCELED",
1226 Self::ManualCanceled => "MANUAL_CANCELED",
1227 Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
1228 Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
1229 Self::ExecuteFailed => "EXECUTE_FAILED",
1230 Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
1231 Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
1232 Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
1233 Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
1234 Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
1235 Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
1236 Self::ServerlessTableNotFoundCanceled => "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1237 };
1238 serializer.serialize_str(variant)
1239 }
1240}
1241impl<'de> serde::Deserialize<'de> for compact_task::TaskStatus {
1242 #[allow(deprecated)]
1243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1244 where
1245 D: serde::Deserializer<'de>,
1246 {
1247 const FIELDS: &[&str] = &[
1248 "UNSPECIFIED",
1249 "PENDING",
1250 "SUCCESS",
1251 "HEARTBEAT_CANCELED",
1252 "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1253 "ASSIGN_FAIL_CANCELED",
1254 "SEND_FAIL_CANCELED",
1255 "MANUAL_CANCELED",
1256 "INVALID_GROUP_CANCELED",
1257 "INPUT_OUTDATED_CANCELED",
1258 "EXECUTE_FAILED",
1259 "JOIN_HANDLE_FAILED",
1260 "TRACK_SST_OBJECT_ID_FAILED",
1261 "NO_AVAIL_CPU_RESOURCE_CANCELED",
1262 "HEARTBEAT_PROGRESS_CANCELED",
1263 "RETENTION_TIME_REJECTED",
1264 "SERVERLESS_SEND_FAIL_CANCELED",
1265 "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1266 ];
1267
1268 struct GeneratedVisitor;
1269
1270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1271 type Value = compact_task::TaskStatus;
1272
1273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1274 write!(formatter, "expected one of: {:?}", &FIELDS)
1275 }
1276
1277 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1278 where
1279 E: serde::de::Error,
1280 {
1281 i32::try_from(v)
1282 .ok()
1283 .and_then(|x| x.try_into().ok())
1284 .ok_or_else(|| {
1285 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1286 })
1287 }
1288
1289 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1290 where
1291 E: serde::de::Error,
1292 {
1293 i32::try_from(v)
1294 .ok()
1295 .and_then(|x| x.try_into().ok())
1296 .ok_or_else(|| {
1297 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1298 })
1299 }
1300
1301 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1302 where
1303 E: serde::de::Error,
1304 {
1305 match value {
1306 "UNSPECIFIED" => Ok(compact_task::TaskStatus::Unspecified),
1307 "PENDING" => Ok(compact_task::TaskStatus::Pending),
1308 "SUCCESS" => Ok(compact_task::TaskStatus::Success),
1309 "HEARTBEAT_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatCanceled),
1310 "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailMemoryResourceCanceled),
1311 "ASSIGN_FAIL_CANCELED" => Ok(compact_task::TaskStatus::AssignFailCanceled),
1312 "SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::SendFailCanceled),
1313 "MANUAL_CANCELED" => Ok(compact_task::TaskStatus::ManualCanceled),
1314 "INVALID_GROUP_CANCELED" => Ok(compact_task::TaskStatus::InvalidGroupCanceled),
1315 "INPUT_OUTDATED_CANCELED" => Ok(compact_task::TaskStatus::InputOutdatedCanceled),
1316 "EXECUTE_FAILED" => Ok(compact_task::TaskStatus::ExecuteFailed),
1317 "JOIN_HANDLE_FAILED" => Ok(compact_task::TaskStatus::JoinHandleFailed),
1318 "TRACK_SST_OBJECT_ID_FAILED" => Ok(compact_task::TaskStatus::TrackSstObjectIdFailed),
1319 "NO_AVAIL_CPU_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailCpuResourceCanceled),
1320 "HEARTBEAT_PROGRESS_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatProgressCanceled),
1321 "RETENTION_TIME_REJECTED" => Ok(compact_task::TaskStatus::RetentionTimeRejected),
1322 "SERVERLESS_SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::ServerlessSendFailCanceled),
1323 "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => Ok(compact_task::TaskStatus::ServerlessTableNotFoundCanceled),
1324 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1325 }
1326 }
1327 }
1328 deserializer.deserialize_any(GeneratedVisitor)
1329 }
1330}
1331impl serde::Serialize for compact_task::TaskType {
1332 #[allow(deprecated)]
1333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1334 where
1335 S: serde::Serializer,
1336 {
1337 let variant = match self {
1338 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1339 Self::Dynamic => "DYNAMIC",
1340 Self::SpaceReclaim => "SPACE_RECLAIM",
1341 Self::Manual => "MANUAL",
1342 Self::SharedBuffer => "SHARED_BUFFER",
1343 Self::Ttl => "TTL",
1344 Self::Tombstone => "TOMBSTONE",
1345 Self::Emergency => "EMERGENCY",
1346 Self::VnodeWatermark => "VNODE_WATERMARK",
1347 };
1348 serializer.serialize_str(variant)
1349 }
1350}
1351impl<'de> serde::Deserialize<'de> for compact_task::TaskType {
1352 #[allow(deprecated)]
1353 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1354 where
1355 D: serde::Deserializer<'de>,
1356 {
1357 const FIELDS: &[&str] = &[
1358 "TYPE_UNSPECIFIED",
1359 "DYNAMIC",
1360 "SPACE_RECLAIM",
1361 "MANUAL",
1362 "SHARED_BUFFER",
1363 "TTL",
1364 "TOMBSTONE",
1365 "EMERGENCY",
1366 "VNODE_WATERMARK",
1367 ];
1368
1369 struct GeneratedVisitor;
1370
1371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1372 type Value = compact_task::TaskType;
1373
1374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1375 write!(formatter, "expected one of: {:?}", &FIELDS)
1376 }
1377
1378 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1379 where
1380 E: serde::de::Error,
1381 {
1382 i32::try_from(v)
1383 .ok()
1384 .and_then(|x| x.try_into().ok())
1385 .ok_or_else(|| {
1386 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1387 })
1388 }
1389
1390 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1391 where
1392 E: serde::de::Error,
1393 {
1394 i32::try_from(v)
1395 .ok()
1396 .and_then(|x| x.try_into().ok())
1397 .ok_or_else(|| {
1398 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1399 })
1400 }
1401
1402 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1403 where
1404 E: serde::de::Error,
1405 {
1406 match value {
1407 "TYPE_UNSPECIFIED" => Ok(compact_task::TaskType::TypeUnspecified),
1408 "DYNAMIC" => Ok(compact_task::TaskType::Dynamic),
1409 "SPACE_RECLAIM" => Ok(compact_task::TaskType::SpaceReclaim),
1410 "MANUAL" => Ok(compact_task::TaskType::Manual),
1411 "SHARED_BUFFER" => Ok(compact_task::TaskType::SharedBuffer),
1412 "TTL" => Ok(compact_task::TaskType::Ttl),
1413 "TOMBSTONE" => Ok(compact_task::TaskType::Tombstone),
1414 "EMERGENCY" => Ok(compact_task::TaskType::Emergency),
1415 "VNODE_WATERMARK" => Ok(compact_task::TaskType::VnodeWatermark),
1416 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1417 }
1418 }
1419 }
1420 deserializer.deserialize_any(GeneratedVisitor)
1421 }
1422}
1423impl serde::Serialize for CompactTaskAssignment {
1424 #[allow(deprecated)]
1425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1426 where
1427 S: serde::Serializer,
1428 {
1429 use serde::ser::SerializeStruct;
1430 let mut len = 0;
1431 if self.compact_task.is_some() {
1432 len += 1;
1433 }
1434 if self.context_id != 0 {
1435 len += 1;
1436 }
1437 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskAssignment", len)?;
1438 if let Some(v) = self.compact_task.as_ref() {
1439 struct_ser.serialize_field("compactTask", v)?;
1440 }
1441 if self.context_id != 0 {
1442 struct_ser.serialize_field("contextId", &self.context_id)?;
1443 }
1444 struct_ser.end()
1445 }
1446}
1447impl<'de> serde::Deserialize<'de> for CompactTaskAssignment {
1448 #[allow(deprecated)]
1449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1450 where
1451 D: serde::Deserializer<'de>,
1452 {
1453 const FIELDS: &[&str] = &[
1454 "compact_task",
1455 "compactTask",
1456 "context_id",
1457 "contextId",
1458 ];
1459
1460 #[allow(clippy::enum_variant_names)]
1461 enum GeneratedField {
1462 CompactTask,
1463 ContextId,
1464 }
1465 impl<'de> serde::Deserialize<'de> for GeneratedField {
1466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1467 where
1468 D: serde::Deserializer<'de>,
1469 {
1470 struct GeneratedVisitor;
1471
1472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1473 type Value = GeneratedField;
1474
1475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1476 write!(formatter, "expected one of: {:?}", &FIELDS)
1477 }
1478
1479 #[allow(unused_variables)]
1480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1481 where
1482 E: serde::de::Error,
1483 {
1484 match value {
1485 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
1486 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
1487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1488 }
1489 }
1490 }
1491 deserializer.deserialize_identifier(GeneratedVisitor)
1492 }
1493 }
1494 struct GeneratedVisitor;
1495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1496 type Value = CompactTaskAssignment;
1497
1498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1499 formatter.write_str("struct hummock.CompactTaskAssignment")
1500 }
1501
1502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskAssignment, V::Error>
1503 where
1504 V: serde::de::MapAccess<'de>,
1505 {
1506 let mut compact_task__ = None;
1507 let mut context_id__ = None;
1508 while let Some(k) = map_.next_key()? {
1509 match k {
1510 GeneratedField::CompactTask => {
1511 if compact_task__.is_some() {
1512 return Err(serde::de::Error::duplicate_field("compactTask"));
1513 }
1514 compact_task__ = map_.next_value()?;
1515 }
1516 GeneratedField::ContextId => {
1517 if context_id__.is_some() {
1518 return Err(serde::de::Error::duplicate_field("contextId"));
1519 }
1520 context_id__ =
1521 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1522 ;
1523 }
1524 }
1525 }
1526 Ok(CompactTaskAssignment {
1527 compact_task: compact_task__,
1528 context_id: context_id__.unwrap_or_default(),
1529 })
1530 }
1531 }
1532 deserializer.deserialize_struct("hummock.CompactTaskAssignment", FIELDS, GeneratedVisitor)
1533 }
1534}
1535impl serde::Serialize for CompactTaskProgress {
1536 #[allow(deprecated)]
1537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1538 where
1539 S: serde::Serializer,
1540 {
1541 use serde::ser::SerializeStruct;
1542 let mut len = 0;
1543 if self.task_id != 0 {
1544 len += 1;
1545 }
1546 if self.num_ssts_sealed != 0 {
1547 len += 1;
1548 }
1549 if self.num_ssts_uploaded != 0 {
1550 len += 1;
1551 }
1552 if self.num_progress_key != 0 {
1553 len += 1;
1554 }
1555 if self.num_pending_read_io != 0 {
1556 len += 1;
1557 }
1558 if self.num_pending_write_io != 0 {
1559 len += 1;
1560 }
1561 if self.compaction_group_id.is_some() {
1562 len += 1;
1563 }
1564 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskProgress", len)?;
1565 if self.task_id != 0 {
1566 #[allow(clippy::needless_borrow)]
1567 #[allow(clippy::needless_borrows_for_generic_args)]
1568 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
1569 }
1570 if self.num_ssts_sealed != 0 {
1571 struct_ser.serialize_field("numSstsSealed", &self.num_ssts_sealed)?;
1572 }
1573 if self.num_ssts_uploaded != 0 {
1574 struct_ser.serialize_field("numSstsUploaded", &self.num_ssts_uploaded)?;
1575 }
1576 if self.num_progress_key != 0 {
1577 #[allow(clippy::needless_borrow)]
1578 #[allow(clippy::needless_borrows_for_generic_args)]
1579 struct_ser.serialize_field("numProgressKey", ToString::to_string(&self.num_progress_key).as_str())?;
1580 }
1581 if self.num_pending_read_io != 0 {
1582 #[allow(clippy::needless_borrow)]
1583 #[allow(clippy::needless_borrows_for_generic_args)]
1584 struct_ser.serialize_field("numPendingReadIo", ToString::to_string(&self.num_pending_read_io).as_str())?;
1585 }
1586 if self.num_pending_write_io != 0 {
1587 #[allow(clippy::needless_borrow)]
1588 #[allow(clippy::needless_borrows_for_generic_args)]
1589 struct_ser.serialize_field("numPendingWriteIo", ToString::to_string(&self.num_pending_write_io).as_str())?;
1590 }
1591 if let Some(v) = self.compaction_group_id.as_ref() {
1592 #[allow(clippy::needless_borrow)]
1593 #[allow(clippy::needless_borrows_for_generic_args)]
1594 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&v).as_str())?;
1595 }
1596 struct_ser.end()
1597 }
1598}
1599impl<'de> serde::Deserialize<'de> for CompactTaskProgress {
1600 #[allow(deprecated)]
1601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1602 where
1603 D: serde::Deserializer<'de>,
1604 {
1605 const FIELDS: &[&str] = &[
1606 "task_id",
1607 "taskId",
1608 "num_ssts_sealed",
1609 "numSstsSealed",
1610 "num_ssts_uploaded",
1611 "numSstsUploaded",
1612 "num_progress_key",
1613 "numProgressKey",
1614 "num_pending_read_io",
1615 "numPendingReadIo",
1616 "num_pending_write_io",
1617 "numPendingWriteIo",
1618 "compaction_group_id",
1619 "compactionGroupId",
1620 ];
1621
1622 #[allow(clippy::enum_variant_names)]
1623 enum GeneratedField {
1624 TaskId,
1625 NumSstsSealed,
1626 NumSstsUploaded,
1627 NumProgressKey,
1628 NumPendingReadIo,
1629 NumPendingWriteIo,
1630 CompactionGroupId,
1631 }
1632 impl<'de> serde::Deserialize<'de> for GeneratedField {
1633 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1634 where
1635 D: serde::Deserializer<'de>,
1636 {
1637 struct GeneratedVisitor;
1638
1639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1640 type Value = GeneratedField;
1641
1642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1643 write!(formatter, "expected one of: {:?}", &FIELDS)
1644 }
1645
1646 #[allow(unused_variables)]
1647 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1648 where
1649 E: serde::de::Error,
1650 {
1651 match value {
1652 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1653 "numSstsSealed" | "num_ssts_sealed" => Ok(GeneratedField::NumSstsSealed),
1654 "numSstsUploaded" | "num_ssts_uploaded" => Ok(GeneratedField::NumSstsUploaded),
1655 "numProgressKey" | "num_progress_key" => Ok(GeneratedField::NumProgressKey),
1656 "numPendingReadIo" | "num_pending_read_io" => Ok(GeneratedField::NumPendingReadIo),
1657 "numPendingWriteIo" | "num_pending_write_io" => Ok(GeneratedField::NumPendingWriteIo),
1658 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1660 }
1661 }
1662 }
1663 deserializer.deserialize_identifier(GeneratedVisitor)
1664 }
1665 }
1666 struct GeneratedVisitor;
1667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1668 type Value = CompactTaskProgress;
1669
1670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1671 formatter.write_str("struct hummock.CompactTaskProgress")
1672 }
1673
1674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskProgress, V::Error>
1675 where
1676 V: serde::de::MapAccess<'de>,
1677 {
1678 let mut task_id__ = None;
1679 let mut num_ssts_sealed__ = None;
1680 let mut num_ssts_uploaded__ = None;
1681 let mut num_progress_key__ = None;
1682 let mut num_pending_read_io__ = None;
1683 let mut num_pending_write_io__ = None;
1684 let mut compaction_group_id__ = None;
1685 while let Some(k) = map_.next_key()? {
1686 match k {
1687 GeneratedField::TaskId => {
1688 if task_id__.is_some() {
1689 return Err(serde::de::Error::duplicate_field("taskId"));
1690 }
1691 task_id__ =
1692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1693 ;
1694 }
1695 GeneratedField::NumSstsSealed => {
1696 if num_ssts_sealed__.is_some() {
1697 return Err(serde::de::Error::duplicate_field("numSstsSealed"));
1698 }
1699 num_ssts_sealed__ =
1700 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1701 ;
1702 }
1703 GeneratedField::NumSstsUploaded => {
1704 if num_ssts_uploaded__.is_some() {
1705 return Err(serde::de::Error::duplicate_field("numSstsUploaded"));
1706 }
1707 num_ssts_uploaded__ =
1708 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1709 ;
1710 }
1711 GeneratedField::NumProgressKey => {
1712 if num_progress_key__.is_some() {
1713 return Err(serde::de::Error::duplicate_field("numProgressKey"));
1714 }
1715 num_progress_key__ =
1716 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1717 ;
1718 }
1719 GeneratedField::NumPendingReadIo => {
1720 if num_pending_read_io__.is_some() {
1721 return Err(serde::de::Error::duplicate_field("numPendingReadIo"));
1722 }
1723 num_pending_read_io__ =
1724 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1725 ;
1726 }
1727 GeneratedField::NumPendingWriteIo => {
1728 if num_pending_write_io__.is_some() {
1729 return Err(serde::de::Error::duplicate_field("numPendingWriteIo"));
1730 }
1731 num_pending_write_io__ =
1732 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1733 ;
1734 }
1735 GeneratedField::CompactionGroupId => {
1736 if compaction_group_id__.is_some() {
1737 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1738 }
1739 compaction_group_id__ =
1740 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1741 ;
1742 }
1743 }
1744 }
1745 Ok(CompactTaskProgress {
1746 task_id: task_id__.unwrap_or_default(),
1747 num_ssts_sealed: num_ssts_sealed__.unwrap_or_default(),
1748 num_ssts_uploaded: num_ssts_uploaded__.unwrap_or_default(),
1749 num_progress_key: num_progress_key__.unwrap_or_default(),
1750 num_pending_read_io: num_pending_read_io__.unwrap_or_default(),
1751 num_pending_write_io: num_pending_write_io__.unwrap_or_default(),
1752 compaction_group_id: compaction_group_id__,
1753 })
1754 }
1755 }
1756 deserializer.deserialize_struct("hummock.CompactTaskProgress", FIELDS, GeneratedVisitor)
1757 }
1758}
1759impl serde::Serialize for CompactionConfig {
1760 #[allow(deprecated)]
1761 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1762 where
1763 S: serde::Serializer,
1764 {
1765 use serde::ser::SerializeStruct;
1766 let mut len = 0;
1767 if self.max_bytes_for_level_base != 0 {
1768 len += 1;
1769 }
1770 if self.max_level != 0 {
1771 len += 1;
1772 }
1773 if self.max_bytes_for_level_multiplier != 0 {
1774 len += 1;
1775 }
1776 if self.max_compaction_bytes != 0 {
1777 len += 1;
1778 }
1779 if self.sub_level_max_compaction_bytes != 0 {
1780 len += 1;
1781 }
1782 if self.level0_tier_compact_file_number != 0 {
1783 len += 1;
1784 }
1785 if self.compaction_mode != 0 {
1786 len += 1;
1787 }
1788 if !self.compression_algorithm.is_empty() {
1789 len += 1;
1790 }
1791 if self.target_file_size_base != 0 {
1792 len += 1;
1793 }
1794 if self.compaction_filter_mask != 0 {
1795 len += 1;
1796 }
1797 if self.max_sub_compaction != 0 {
1798 len += 1;
1799 }
1800 if self.max_space_reclaim_bytes != 0 {
1801 len += 1;
1802 }
1803 if self.split_by_state_table {
1804 len += 1;
1805 }
1806 if self.split_weight_by_vnode != 0 {
1807 len += 1;
1808 }
1809 if self.level0_stop_write_threshold_sub_level_number != 0 {
1810 len += 1;
1811 }
1812 if self.level0_max_compact_file_number != 0 {
1813 len += 1;
1814 }
1815 if self.level0_sub_level_compact_level_count != 0 {
1816 len += 1;
1817 }
1818 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1819 len += 1;
1820 }
1821 if self.tombstone_reclaim_ratio != 0 {
1822 len += 1;
1823 }
1824 if self.enable_emergency_picker {
1825 len += 1;
1826 }
1827 if self.max_l0_compact_level_count.is_some() {
1828 len += 1;
1829 }
1830 if self.sst_allowed_trivial_move_min_size.is_some() {
1831 len += 1;
1832 }
1833 if self.disable_auto_group_scheduling.is_some() {
1834 len += 1;
1835 }
1836 if self.max_overlapping_level_size.is_some() {
1837 len += 1;
1838 }
1839 if self.emergency_level0_sst_file_count.is_some() {
1840 len += 1;
1841 }
1842 if self.emergency_level0_sub_level_partition.is_some() {
1843 len += 1;
1844 }
1845 if self.level0_stop_write_threshold_max_sst_count.is_some() {
1846 len += 1;
1847 }
1848 if self.level0_stop_write_threshold_max_size.is_some() {
1849 len += 1;
1850 }
1851 if self.sst_allowed_trivial_move_max_count.is_some() {
1852 len += 1;
1853 }
1854 if self.enable_optimize_l0_interval_selection.is_some() {
1855 len += 1;
1856 }
1857 let mut struct_ser = serializer.serialize_struct("hummock.CompactionConfig", len)?;
1858 if self.max_bytes_for_level_base != 0 {
1859 #[allow(clippy::needless_borrow)]
1860 #[allow(clippy::needless_borrows_for_generic_args)]
1861 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&self.max_bytes_for_level_base).as_str())?;
1862 }
1863 if self.max_level != 0 {
1864 #[allow(clippy::needless_borrow)]
1865 #[allow(clippy::needless_borrows_for_generic_args)]
1866 struct_ser.serialize_field("maxLevel", ToString::to_string(&self.max_level).as_str())?;
1867 }
1868 if self.max_bytes_for_level_multiplier != 0 {
1869 #[allow(clippy::needless_borrow)]
1870 #[allow(clippy::needless_borrows_for_generic_args)]
1871 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&self.max_bytes_for_level_multiplier).as_str())?;
1872 }
1873 if self.max_compaction_bytes != 0 {
1874 #[allow(clippy::needless_borrow)]
1875 #[allow(clippy::needless_borrows_for_generic_args)]
1876 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&self.max_compaction_bytes).as_str())?;
1877 }
1878 if self.sub_level_max_compaction_bytes != 0 {
1879 #[allow(clippy::needless_borrow)]
1880 #[allow(clippy::needless_borrows_for_generic_args)]
1881 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&self.sub_level_max_compaction_bytes).as_str())?;
1882 }
1883 if self.level0_tier_compact_file_number != 0 {
1884 #[allow(clippy::needless_borrow)]
1885 #[allow(clippy::needless_borrows_for_generic_args)]
1886 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&self.level0_tier_compact_file_number).as_str())?;
1887 }
1888 if self.compaction_mode != 0 {
1889 let v = compaction_config::CompactionMode::try_from(self.compaction_mode)
1890 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compaction_mode)))?;
1891 struct_ser.serialize_field("compactionMode", &v)?;
1892 }
1893 if !self.compression_algorithm.is_empty() {
1894 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
1895 }
1896 if self.target_file_size_base != 0 {
1897 #[allow(clippy::needless_borrow)]
1898 #[allow(clippy::needless_borrows_for_generic_args)]
1899 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&self.target_file_size_base).as_str())?;
1900 }
1901 if self.compaction_filter_mask != 0 {
1902 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
1903 }
1904 if self.max_sub_compaction != 0 {
1905 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
1906 }
1907 if self.max_space_reclaim_bytes != 0 {
1908 #[allow(clippy::needless_borrow)]
1909 #[allow(clippy::needless_borrows_for_generic_args)]
1910 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&self.max_space_reclaim_bytes).as_str())?;
1911 }
1912 if self.split_by_state_table {
1913 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
1914 }
1915 if self.split_weight_by_vnode != 0 {
1916 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
1917 }
1918 if self.level0_stop_write_threshold_sub_level_number != 0 {
1919 #[allow(clippy::needless_borrow)]
1920 #[allow(clippy::needless_borrows_for_generic_args)]
1921 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&self.level0_stop_write_threshold_sub_level_number).as_str())?;
1922 }
1923 if self.level0_max_compact_file_number != 0 {
1924 #[allow(clippy::needless_borrow)]
1925 #[allow(clippy::needless_borrows_for_generic_args)]
1926 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&self.level0_max_compact_file_number).as_str())?;
1927 }
1928 if self.level0_sub_level_compact_level_count != 0 {
1929 struct_ser.serialize_field("level0SubLevelCompactLevelCount", &self.level0_sub_level_compact_level_count)?;
1930 }
1931 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1932 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", &self.level0_overlapping_sub_level_compact_level_count)?;
1933 }
1934 if self.tombstone_reclaim_ratio != 0 {
1935 struct_ser.serialize_field("tombstoneReclaimRatio", &self.tombstone_reclaim_ratio)?;
1936 }
1937 if self.enable_emergency_picker {
1938 struct_ser.serialize_field("enableEmergencyPicker", &self.enable_emergency_picker)?;
1939 }
1940 if let Some(v) = self.max_l0_compact_level_count.as_ref() {
1941 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
1942 }
1943 if let Some(v) = self.sst_allowed_trivial_move_min_size.as_ref() {
1944 #[allow(clippy::needless_borrow)]
1945 #[allow(clippy::needless_borrows_for_generic_args)]
1946 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
1947 }
1948 if let Some(v) = self.disable_auto_group_scheduling.as_ref() {
1949 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
1950 }
1951 if let Some(v) = self.max_overlapping_level_size.as_ref() {
1952 #[allow(clippy::needless_borrow)]
1953 #[allow(clippy::needless_borrows_for_generic_args)]
1954 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
1955 }
1956 if let Some(v) = self.emergency_level0_sst_file_count.as_ref() {
1957 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
1958 }
1959 if let Some(v) = self.emergency_level0_sub_level_partition.as_ref() {
1960 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
1961 }
1962 if let Some(v) = self.level0_stop_write_threshold_max_sst_count.as_ref() {
1963 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
1964 }
1965 if let Some(v) = self.level0_stop_write_threshold_max_size.as_ref() {
1966 #[allow(clippy::needless_borrow)]
1967 #[allow(clippy::needless_borrows_for_generic_args)]
1968 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
1969 }
1970 if let Some(v) = self.sst_allowed_trivial_move_max_count.as_ref() {
1971 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
1972 }
1973 if let Some(v) = self.enable_optimize_l0_interval_selection.as_ref() {
1974 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
1975 }
1976 struct_ser.end()
1977 }
1978}
1979impl<'de> serde::Deserialize<'de> for CompactionConfig {
1980 #[allow(deprecated)]
1981 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1982 where
1983 D: serde::Deserializer<'de>,
1984 {
1985 const FIELDS: &[&str] = &[
1986 "max_bytes_for_level_base",
1987 "maxBytesForLevelBase",
1988 "max_level",
1989 "maxLevel",
1990 "max_bytes_for_level_multiplier",
1991 "maxBytesForLevelMultiplier",
1992 "max_compaction_bytes",
1993 "maxCompactionBytes",
1994 "sub_level_max_compaction_bytes",
1995 "subLevelMaxCompactionBytes",
1996 "level0_tier_compact_file_number",
1997 "level0TierCompactFileNumber",
1998 "compaction_mode",
1999 "compactionMode",
2000 "compression_algorithm",
2001 "compressionAlgorithm",
2002 "target_file_size_base",
2003 "targetFileSizeBase",
2004 "compaction_filter_mask",
2005 "compactionFilterMask",
2006 "max_sub_compaction",
2007 "maxSubCompaction",
2008 "max_space_reclaim_bytes",
2009 "maxSpaceReclaimBytes",
2010 "split_by_state_table",
2011 "splitByStateTable",
2012 "split_weight_by_vnode",
2013 "splitWeightByVnode",
2014 "level0_stop_write_threshold_sub_level_number",
2015 "level0StopWriteThresholdSubLevelNumber",
2016 "level0_max_compact_file_number",
2017 "level0MaxCompactFileNumber",
2018 "level0_sub_level_compact_level_count",
2019 "level0SubLevelCompactLevelCount",
2020 "level0_overlapping_sub_level_compact_level_count",
2021 "level0OverlappingSubLevelCompactLevelCount",
2022 "tombstone_reclaim_ratio",
2023 "tombstoneReclaimRatio",
2024 "enable_emergency_picker",
2025 "enableEmergencyPicker",
2026 "max_l0_compact_level_count",
2027 "maxL0CompactLevelCount",
2028 "sst_allowed_trivial_move_min_size",
2029 "sstAllowedTrivialMoveMinSize",
2030 "disable_auto_group_scheduling",
2031 "disableAutoGroupScheduling",
2032 "max_overlapping_level_size",
2033 "maxOverlappingLevelSize",
2034 "emergency_level0_sst_file_count",
2035 "emergencyLevel0SstFileCount",
2036 "emergency_level0_sub_level_partition",
2037 "emergencyLevel0SubLevelPartition",
2038 "level0_stop_write_threshold_max_sst_count",
2039 "level0StopWriteThresholdMaxSstCount",
2040 "level0_stop_write_threshold_max_size",
2041 "level0StopWriteThresholdMaxSize",
2042 "sst_allowed_trivial_move_max_count",
2043 "sstAllowedTrivialMoveMaxCount",
2044 "enable_optimize_l0_interval_selection",
2045 "enableOptimizeL0IntervalSelection",
2046 ];
2047
2048 #[allow(clippy::enum_variant_names)]
2049 enum GeneratedField {
2050 MaxBytesForLevelBase,
2051 MaxLevel,
2052 MaxBytesForLevelMultiplier,
2053 MaxCompactionBytes,
2054 SubLevelMaxCompactionBytes,
2055 Level0TierCompactFileNumber,
2056 CompactionMode,
2057 CompressionAlgorithm,
2058 TargetFileSizeBase,
2059 CompactionFilterMask,
2060 MaxSubCompaction,
2061 MaxSpaceReclaimBytes,
2062 SplitByStateTable,
2063 SplitWeightByVnode,
2064 Level0StopWriteThresholdSubLevelNumber,
2065 Level0MaxCompactFileNumber,
2066 Level0SubLevelCompactLevelCount,
2067 Level0OverlappingSubLevelCompactLevelCount,
2068 TombstoneReclaimRatio,
2069 EnableEmergencyPicker,
2070 MaxL0CompactLevelCount,
2071 SstAllowedTrivialMoveMinSize,
2072 DisableAutoGroupScheduling,
2073 MaxOverlappingLevelSize,
2074 EmergencyLevel0SstFileCount,
2075 EmergencyLevel0SubLevelPartition,
2076 Level0StopWriteThresholdMaxSstCount,
2077 Level0StopWriteThresholdMaxSize,
2078 SstAllowedTrivialMoveMaxCount,
2079 EnableOptimizeL0IntervalSelection,
2080 }
2081 impl<'de> serde::Deserialize<'de> for GeneratedField {
2082 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2083 where
2084 D: serde::Deserializer<'de>,
2085 {
2086 struct GeneratedVisitor;
2087
2088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2089 type Value = GeneratedField;
2090
2091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2092 write!(formatter, "expected one of: {:?}", &FIELDS)
2093 }
2094
2095 #[allow(unused_variables)]
2096 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2097 where
2098 E: serde::de::Error,
2099 {
2100 match value {
2101 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
2102 "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2103 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
2104 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
2105 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
2106 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
2107 "compactionMode" | "compaction_mode" => Ok(GeneratedField::CompactionMode),
2108 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
2109 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
2110 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
2111 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
2112 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
2113 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
2114 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
2115 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
2116 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
2117 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
2118 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
2119 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
2120 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
2121 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
2122 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
2123 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
2124 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
2125 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
2126 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
2127 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
2128 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
2129 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
2130 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
2131 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2132 }
2133 }
2134 }
2135 deserializer.deserialize_identifier(GeneratedVisitor)
2136 }
2137 }
2138 struct GeneratedVisitor;
2139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2140 type Value = CompactionConfig;
2141
2142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2143 formatter.write_str("struct hummock.CompactionConfig")
2144 }
2145
2146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionConfig, V::Error>
2147 where
2148 V: serde::de::MapAccess<'de>,
2149 {
2150 let mut max_bytes_for_level_base__ = None;
2151 let mut max_level__ = None;
2152 let mut max_bytes_for_level_multiplier__ = None;
2153 let mut max_compaction_bytes__ = None;
2154 let mut sub_level_max_compaction_bytes__ = None;
2155 let mut level0_tier_compact_file_number__ = None;
2156 let mut compaction_mode__ = None;
2157 let mut compression_algorithm__ = None;
2158 let mut target_file_size_base__ = None;
2159 let mut compaction_filter_mask__ = None;
2160 let mut max_sub_compaction__ = None;
2161 let mut max_space_reclaim_bytes__ = None;
2162 let mut split_by_state_table__ = None;
2163 let mut split_weight_by_vnode__ = None;
2164 let mut level0_stop_write_threshold_sub_level_number__ = None;
2165 let mut level0_max_compact_file_number__ = None;
2166 let mut level0_sub_level_compact_level_count__ = None;
2167 let mut level0_overlapping_sub_level_compact_level_count__ = None;
2168 let mut tombstone_reclaim_ratio__ = None;
2169 let mut enable_emergency_picker__ = None;
2170 let mut max_l0_compact_level_count__ = None;
2171 let mut sst_allowed_trivial_move_min_size__ = None;
2172 let mut disable_auto_group_scheduling__ = None;
2173 let mut max_overlapping_level_size__ = None;
2174 let mut emergency_level0_sst_file_count__ = None;
2175 let mut emergency_level0_sub_level_partition__ = None;
2176 let mut level0_stop_write_threshold_max_sst_count__ = None;
2177 let mut level0_stop_write_threshold_max_size__ = None;
2178 let mut sst_allowed_trivial_move_max_count__ = None;
2179 let mut enable_optimize_l0_interval_selection__ = None;
2180 while let Some(k) = map_.next_key()? {
2181 match k {
2182 GeneratedField::MaxBytesForLevelBase => {
2183 if max_bytes_for_level_base__.is_some() {
2184 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
2185 }
2186 max_bytes_for_level_base__ =
2187 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2188 ;
2189 }
2190 GeneratedField::MaxLevel => {
2191 if max_level__.is_some() {
2192 return Err(serde::de::Error::duplicate_field("maxLevel"));
2193 }
2194 max_level__ =
2195 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2196 ;
2197 }
2198 GeneratedField::MaxBytesForLevelMultiplier => {
2199 if max_bytes_for_level_multiplier__.is_some() {
2200 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
2201 }
2202 max_bytes_for_level_multiplier__ =
2203 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2204 ;
2205 }
2206 GeneratedField::MaxCompactionBytes => {
2207 if max_compaction_bytes__.is_some() {
2208 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
2209 }
2210 max_compaction_bytes__ =
2211 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2212 ;
2213 }
2214 GeneratedField::SubLevelMaxCompactionBytes => {
2215 if sub_level_max_compaction_bytes__.is_some() {
2216 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
2217 }
2218 sub_level_max_compaction_bytes__ =
2219 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2220 ;
2221 }
2222 GeneratedField::Level0TierCompactFileNumber => {
2223 if level0_tier_compact_file_number__.is_some() {
2224 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
2225 }
2226 level0_tier_compact_file_number__ =
2227 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2228 ;
2229 }
2230 GeneratedField::CompactionMode => {
2231 if compaction_mode__.is_some() {
2232 return Err(serde::de::Error::duplicate_field("compactionMode"));
2233 }
2234 compaction_mode__ = Some(map_.next_value::<compaction_config::CompactionMode>()? as i32);
2235 }
2236 GeneratedField::CompressionAlgorithm => {
2237 if compression_algorithm__.is_some() {
2238 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
2239 }
2240 compression_algorithm__ = Some(map_.next_value()?);
2241 }
2242 GeneratedField::TargetFileSizeBase => {
2243 if target_file_size_base__.is_some() {
2244 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
2245 }
2246 target_file_size_base__ =
2247 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2248 ;
2249 }
2250 GeneratedField::CompactionFilterMask => {
2251 if compaction_filter_mask__.is_some() {
2252 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
2253 }
2254 compaction_filter_mask__ =
2255 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2256 ;
2257 }
2258 GeneratedField::MaxSubCompaction => {
2259 if max_sub_compaction__.is_some() {
2260 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
2261 }
2262 max_sub_compaction__ =
2263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2264 ;
2265 }
2266 GeneratedField::MaxSpaceReclaimBytes => {
2267 if max_space_reclaim_bytes__.is_some() {
2268 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
2269 }
2270 max_space_reclaim_bytes__ =
2271 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2272 ;
2273 }
2274 GeneratedField::SplitByStateTable => {
2275 if split_by_state_table__.is_some() {
2276 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
2277 }
2278 split_by_state_table__ = Some(map_.next_value()?);
2279 }
2280 GeneratedField::SplitWeightByVnode => {
2281 if split_weight_by_vnode__.is_some() {
2282 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
2283 }
2284 split_weight_by_vnode__ =
2285 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2286 ;
2287 }
2288 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
2289 if level0_stop_write_threshold_sub_level_number__.is_some() {
2290 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
2291 }
2292 level0_stop_write_threshold_sub_level_number__ =
2293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2294 ;
2295 }
2296 GeneratedField::Level0MaxCompactFileNumber => {
2297 if level0_max_compact_file_number__.is_some() {
2298 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
2299 }
2300 level0_max_compact_file_number__ =
2301 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2302 ;
2303 }
2304 GeneratedField::Level0SubLevelCompactLevelCount => {
2305 if level0_sub_level_compact_level_count__.is_some() {
2306 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
2307 }
2308 level0_sub_level_compact_level_count__ =
2309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2310 ;
2311 }
2312 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
2313 if level0_overlapping_sub_level_compact_level_count__.is_some() {
2314 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
2315 }
2316 level0_overlapping_sub_level_compact_level_count__ =
2317 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2318 ;
2319 }
2320 GeneratedField::TombstoneReclaimRatio => {
2321 if tombstone_reclaim_ratio__.is_some() {
2322 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
2323 }
2324 tombstone_reclaim_ratio__ =
2325 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2326 ;
2327 }
2328 GeneratedField::EnableEmergencyPicker => {
2329 if enable_emergency_picker__.is_some() {
2330 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
2331 }
2332 enable_emergency_picker__ = Some(map_.next_value()?);
2333 }
2334 GeneratedField::MaxL0CompactLevelCount => {
2335 if max_l0_compact_level_count__.is_some() {
2336 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
2337 }
2338 max_l0_compact_level_count__ =
2339 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2340 ;
2341 }
2342 GeneratedField::SstAllowedTrivialMoveMinSize => {
2343 if sst_allowed_trivial_move_min_size__.is_some() {
2344 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
2345 }
2346 sst_allowed_trivial_move_min_size__ =
2347 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2348 ;
2349 }
2350 GeneratedField::DisableAutoGroupScheduling => {
2351 if disable_auto_group_scheduling__.is_some() {
2352 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
2353 }
2354 disable_auto_group_scheduling__ = map_.next_value()?;
2355 }
2356 GeneratedField::MaxOverlappingLevelSize => {
2357 if max_overlapping_level_size__.is_some() {
2358 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
2359 }
2360 max_overlapping_level_size__ =
2361 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2362 ;
2363 }
2364 GeneratedField::EmergencyLevel0SstFileCount => {
2365 if emergency_level0_sst_file_count__.is_some() {
2366 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
2367 }
2368 emergency_level0_sst_file_count__ =
2369 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2370 ;
2371 }
2372 GeneratedField::EmergencyLevel0SubLevelPartition => {
2373 if emergency_level0_sub_level_partition__.is_some() {
2374 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
2375 }
2376 emergency_level0_sub_level_partition__ =
2377 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2378 ;
2379 }
2380 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
2381 if level0_stop_write_threshold_max_sst_count__.is_some() {
2382 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
2383 }
2384 level0_stop_write_threshold_max_sst_count__ =
2385 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2386 ;
2387 }
2388 GeneratedField::Level0StopWriteThresholdMaxSize => {
2389 if level0_stop_write_threshold_max_size__.is_some() {
2390 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
2391 }
2392 level0_stop_write_threshold_max_size__ =
2393 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2394 ;
2395 }
2396 GeneratedField::SstAllowedTrivialMoveMaxCount => {
2397 if sst_allowed_trivial_move_max_count__.is_some() {
2398 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
2399 }
2400 sst_allowed_trivial_move_max_count__ =
2401 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2402 ;
2403 }
2404 GeneratedField::EnableOptimizeL0IntervalSelection => {
2405 if enable_optimize_l0_interval_selection__.is_some() {
2406 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
2407 }
2408 enable_optimize_l0_interval_selection__ = map_.next_value()?;
2409 }
2410 }
2411 }
2412 Ok(CompactionConfig {
2413 max_bytes_for_level_base: max_bytes_for_level_base__.unwrap_or_default(),
2414 max_level: max_level__.unwrap_or_default(),
2415 max_bytes_for_level_multiplier: max_bytes_for_level_multiplier__.unwrap_or_default(),
2416 max_compaction_bytes: max_compaction_bytes__.unwrap_or_default(),
2417 sub_level_max_compaction_bytes: sub_level_max_compaction_bytes__.unwrap_or_default(),
2418 level0_tier_compact_file_number: level0_tier_compact_file_number__.unwrap_or_default(),
2419 compaction_mode: compaction_mode__.unwrap_or_default(),
2420 compression_algorithm: compression_algorithm__.unwrap_or_default(),
2421 target_file_size_base: target_file_size_base__.unwrap_or_default(),
2422 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
2423 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
2424 max_space_reclaim_bytes: max_space_reclaim_bytes__.unwrap_or_default(),
2425 split_by_state_table: split_by_state_table__.unwrap_or_default(),
2426 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
2427 level0_stop_write_threshold_sub_level_number: level0_stop_write_threshold_sub_level_number__.unwrap_or_default(),
2428 level0_max_compact_file_number: level0_max_compact_file_number__.unwrap_or_default(),
2429 level0_sub_level_compact_level_count: level0_sub_level_compact_level_count__.unwrap_or_default(),
2430 level0_overlapping_sub_level_compact_level_count: level0_overlapping_sub_level_compact_level_count__.unwrap_or_default(),
2431 tombstone_reclaim_ratio: tombstone_reclaim_ratio__.unwrap_or_default(),
2432 enable_emergency_picker: enable_emergency_picker__.unwrap_or_default(),
2433 max_l0_compact_level_count: max_l0_compact_level_count__,
2434 sst_allowed_trivial_move_min_size: sst_allowed_trivial_move_min_size__,
2435 disable_auto_group_scheduling: disable_auto_group_scheduling__,
2436 max_overlapping_level_size: max_overlapping_level_size__,
2437 emergency_level0_sst_file_count: emergency_level0_sst_file_count__,
2438 emergency_level0_sub_level_partition: emergency_level0_sub_level_partition__,
2439 level0_stop_write_threshold_max_sst_count: level0_stop_write_threshold_max_sst_count__,
2440 level0_stop_write_threshold_max_size: level0_stop_write_threshold_max_size__,
2441 sst_allowed_trivial_move_max_count: sst_allowed_trivial_move_max_count__,
2442 enable_optimize_l0_interval_selection: enable_optimize_l0_interval_selection__,
2443 })
2444 }
2445 }
2446 deserializer.deserialize_struct("hummock.CompactionConfig", FIELDS, GeneratedVisitor)
2447 }
2448}
2449impl serde::Serialize for compaction_config::CompactionMode {
2450 #[allow(deprecated)]
2451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2452 where
2453 S: serde::Serializer,
2454 {
2455 let variant = match self {
2456 Self::Unspecified => "UNSPECIFIED",
2457 Self::Range => "RANGE",
2458 };
2459 serializer.serialize_str(variant)
2460 }
2461}
2462impl<'de> serde::Deserialize<'de> for compaction_config::CompactionMode {
2463 #[allow(deprecated)]
2464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2465 where
2466 D: serde::Deserializer<'de>,
2467 {
2468 const FIELDS: &[&str] = &[
2469 "UNSPECIFIED",
2470 "RANGE",
2471 ];
2472
2473 struct GeneratedVisitor;
2474
2475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2476 type Value = compaction_config::CompactionMode;
2477
2478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2479 write!(formatter, "expected one of: {:?}", &FIELDS)
2480 }
2481
2482 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2483 where
2484 E: serde::de::Error,
2485 {
2486 i32::try_from(v)
2487 .ok()
2488 .and_then(|x| x.try_into().ok())
2489 .ok_or_else(|| {
2490 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2491 })
2492 }
2493
2494 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2495 where
2496 E: serde::de::Error,
2497 {
2498 i32::try_from(v)
2499 .ok()
2500 .and_then(|x| x.try_into().ok())
2501 .ok_or_else(|| {
2502 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2503 })
2504 }
2505
2506 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2507 where
2508 E: serde::de::Error,
2509 {
2510 match value {
2511 "UNSPECIFIED" => Ok(compaction_config::CompactionMode::Unspecified),
2512 "RANGE" => Ok(compaction_config::CompactionMode::Range),
2513 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2514 }
2515 }
2516 }
2517 deserializer.deserialize_any(GeneratedVisitor)
2518 }
2519}
2520impl serde::Serialize for CompactionGroup {
2521 #[allow(deprecated)]
2522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2523 where
2524 S: serde::Serializer,
2525 {
2526 use serde::ser::SerializeStruct;
2527 let mut len = 0;
2528 if self.id != 0 {
2529 len += 1;
2530 }
2531 if self.compaction_config.is_some() {
2532 len += 1;
2533 }
2534 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroup", len)?;
2535 if self.id != 0 {
2536 #[allow(clippy::needless_borrow)]
2537 #[allow(clippy::needless_borrows_for_generic_args)]
2538 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2539 }
2540 if let Some(v) = self.compaction_config.as_ref() {
2541 struct_ser.serialize_field("compactionConfig", v)?;
2542 }
2543 struct_ser.end()
2544 }
2545}
2546impl<'de> serde::Deserialize<'de> for CompactionGroup {
2547 #[allow(deprecated)]
2548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2549 where
2550 D: serde::Deserializer<'de>,
2551 {
2552 const FIELDS: &[&str] = &[
2553 "id",
2554 "compaction_config",
2555 "compactionConfig",
2556 ];
2557
2558 #[allow(clippy::enum_variant_names)]
2559 enum GeneratedField {
2560 Id,
2561 CompactionConfig,
2562 }
2563 impl<'de> serde::Deserialize<'de> for GeneratedField {
2564 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2565 where
2566 D: serde::Deserializer<'de>,
2567 {
2568 struct GeneratedVisitor;
2569
2570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2571 type Value = GeneratedField;
2572
2573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2574 write!(formatter, "expected one of: {:?}", &FIELDS)
2575 }
2576
2577 #[allow(unused_variables)]
2578 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2579 where
2580 E: serde::de::Error,
2581 {
2582 match value {
2583 "id" => Ok(GeneratedField::Id),
2584 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2585 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2586 }
2587 }
2588 }
2589 deserializer.deserialize_identifier(GeneratedVisitor)
2590 }
2591 }
2592 struct GeneratedVisitor;
2593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2594 type Value = CompactionGroup;
2595
2596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2597 formatter.write_str("struct hummock.CompactionGroup")
2598 }
2599
2600 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroup, V::Error>
2601 where
2602 V: serde::de::MapAccess<'de>,
2603 {
2604 let mut id__ = None;
2605 let mut compaction_config__ = None;
2606 while let Some(k) = map_.next_key()? {
2607 match k {
2608 GeneratedField::Id => {
2609 if id__.is_some() {
2610 return Err(serde::de::Error::duplicate_field("id"));
2611 }
2612 id__ =
2613 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2614 ;
2615 }
2616 GeneratedField::CompactionConfig => {
2617 if compaction_config__.is_some() {
2618 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2619 }
2620 compaction_config__ = map_.next_value()?;
2621 }
2622 }
2623 }
2624 Ok(CompactionGroup {
2625 id: id__.unwrap_or_default(),
2626 compaction_config: compaction_config__,
2627 })
2628 }
2629 }
2630 deserializer.deserialize_struct("hummock.CompactionGroup", FIELDS, GeneratedVisitor)
2631 }
2632}
2633impl serde::Serialize for CompactionGroupInfo {
2634 #[allow(deprecated)]
2635 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2636 where
2637 S: serde::Serializer,
2638 {
2639 use serde::ser::SerializeStruct;
2640 let mut len = 0;
2641 if self.id != 0 {
2642 len += 1;
2643 }
2644 if self.parent_id != 0 {
2645 len += 1;
2646 }
2647 if !self.member_table_ids.is_empty() {
2648 len += 1;
2649 }
2650 if self.compaction_config.is_some() {
2651 len += 1;
2652 }
2653 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroupInfo", len)?;
2654 if self.id != 0 {
2655 #[allow(clippy::needless_borrow)]
2656 #[allow(clippy::needless_borrows_for_generic_args)]
2657 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2658 }
2659 if self.parent_id != 0 {
2660 #[allow(clippy::needless_borrow)]
2661 #[allow(clippy::needless_borrows_for_generic_args)]
2662 struct_ser.serialize_field("parentId", ToString::to_string(&self.parent_id).as_str())?;
2663 }
2664 if !self.member_table_ids.is_empty() {
2665 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
2666 }
2667 if let Some(v) = self.compaction_config.as_ref() {
2668 struct_ser.serialize_field("compactionConfig", v)?;
2669 }
2670 struct_ser.end()
2671 }
2672}
2673impl<'de> serde::Deserialize<'de> for CompactionGroupInfo {
2674 #[allow(deprecated)]
2675 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2676 where
2677 D: serde::Deserializer<'de>,
2678 {
2679 const FIELDS: &[&str] = &[
2680 "id",
2681 "parent_id",
2682 "parentId",
2683 "member_table_ids",
2684 "memberTableIds",
2685 "compaction_config",
2686 "compactionConfig",
2687 ];
2688
2689 #[allow(clippy::enum_variant_names)]
2690 enum GeneratedField {
2691 Id,
2692 ParentId,
2693 MemberTableIds,
2694 CompactionConfig,
2695 }
2696 impl<'de> serde::Deserialize<'de> for GeneratedField {
2697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2698 where
2699 D: serde::Deserializer<'de>,
2700 {
2701 struct GeneratedVisitor;
2702
2703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2704 type Value = GeneratedField;
2705
2706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2707 write!(formatter, "expected one of: {:?}", &FIELDS)
2708 }
2709
2710 #[allow(unused_variables)]
2711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2712 where
2713 E: serde::de::Error,
2714 {
2715 match value {
2716 "id" => Ok(GeneratedField::Id),
2717 "parentId" | "parent_id" => Ok(GeneratedField::ParentId),
2718 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
2719 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2721 }
2722 }
2723 }
2724 deserializer.deserialize_identifier(GeneratedVisitor)
2725 }
2726 }
2727 struct GeneratedVisitor;
2728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2729 type Value = CompactionGroupInfo;
2730
2731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2732 formatter.write_str("struct hummock.CompactionGroupInfo")
2733 }
2734
2735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroupInfo, V::Error>
2736 where
2737 V: serde::de::MapAccess<'de>,
2738 {
2739 let mut id__ = None;
2740 let mut parent_id__ = None;
2741 let mut member_table_ids__ = None;
2742 let mut compaction_config__ = None;
2743 while let Some(k) = map_.next_key()? {
2744 match k {
2745 GeneratedField::Id => {
2746 if id__.is_some() {
2747 return Err(serde::de::Error::duplicate_field("id"));
2748 }
2749 id__ =
2750 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2751 ;
2752 }
2753 GeneratedField::ParentId => {
2754 if parent_id__.is_some() {
2755 return Err(serde::de::Error::duplicate_field("parentId"));
2756 }
2757 parent_id__ =
2758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2759 ;
2760 }
2761 GeneratedField::MemberTableIds => {
2762 if member_table_ids__.is_some() {
2763 return Err(serde::de::Error::duplicate_field("memberTableIds"));
2764 }
2765 member_table_ids__ =
2766 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2767 .into_iter().map(|x| x.0).collect())
2768 ;
2769 }
2770 GeneratedField::CompactionConfig => {
2771 if compaction_config__.is_some() {
2772 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2773 }
2774 compaction_config__ = map_.next_value()?;
2775 }
2776 }
2777 }
2778 Ok(CompactionGroupInfo {
2779 id: id__.unwrap_or_default(),
2780 parent_id: parent_id__.unwrap_or_default(),
2781 member_table_ids: member_table_ids__.unwrap_or_default(),
2782 compaction_config: compaction_config__,
2783 })
2784 }
2785 }
2786 deserializer.deserialize_struct("hummock.CompactionGroupInfo", FIELDS, GeneratedVisitor)
2787 }
2788}
2789impl serde::Serialize for CompatibilityVersion {
2790 #[allow(deprecated)]
2791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2792 where
2793 S: serde::Serializer,
2794 {
2795 let variant = match self {
2796 Self::VersionUnspecified => "VERSION_UNSPECIFIED",
2797 Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
2798 Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
2799 Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
2800 };
2801 serializer.serialize_str(variant)
2802 }
2803}
2804impl<'de> serde::Deserialize<'de> for CompatibilityVersion {
2805 #[allow(deprecated)]
2806 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2807 where
2808 D: serde::Deserializer<'de>,
2809 {
2810 const FIELDS: &[&str] = &[
2811 "VERSION_UNSPECIFIED",
2812 "NO_TRIVIAL_SPLIT",
2813 "NO_MEMBER_TABLE_IDS",
2814 "SPLIT_GROUP_BY_TABLE_ID",
2815 ];
2816
2817 struct GeneratedVisitor;
2818
2819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2820 type Value = CompatibilityVersion;
2821
2822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2823 write!(formatter, "expected one of: {:?}", &FIELDS)
2824 }
2825
2826 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2827 where
2828 E: serde::de::Error,
2829 {
2830 i32::try_from(v)
2831 .ok()
2832 .and_then(|x| x.try_into().ok())
2833 .ok_or_else(|| {
2834 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2835 })
2836 }
2837
2838 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2839 where
2840 E: serde::de::Error,
2841 {
2842 i32::try_from(v)
2843 .ok()
2844 .and_then(|x| x.try_into().ok())
2845 .ok_or_else(|| {
2846 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2847 })
2848 }
2849
2850 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2851 where
2852 E: serde::de::Error,
2853 {
2854 match value {
2855 "VERSION_UNSPECIFIED" => Ok(CompatibilityVersion::VersionUnspecified),
2856 "NO_TRIVIAL_SPLIT" => Ok(CompatibilityVersion::NoTrivialSplit),
2857 "NO_MEMBER_TABLE_IDS" => Ok(CompatibilityVersion::NoMemberTableIds),
2858 "SPLIT_GROUP_BY_TABLE_ID" => Ok(CompatibilityVersion::SplitGroupByTableId),
2859 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2860 }
2861 }
2862 }
2863 deserializer.deserialize_any(GeneratedVisitor)
2864 }
2865}
2866impl serde::Serialize for DisableCommitEpochRequest {
2867 #[allow(deprecated)]
2868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2869 where
2870 S: serde::Serializer,
2871 {
2872 use serde::ser::SerializeStruct;
2873 let len = 0;
2874 let struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochRequest", len)?;
2875 struct_ser.end()
2876 }
2877}
2878impl<'de> serde::Deserialize<'de> for DisableCommitEpochRequest {
2879 #[allow(deprecated)]
2880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2881 where
2882 D: serde::Deserializer<'de>,
2883 {
2884 const FIELDS: &[&str] = &[
2885 ];
2886
2887 #[allow(clippy::enum_variant_names)]
2888 enum GeneratedField {
2889 }
2890 impl<'de> serde::Deserialize<'de> for GeneratedField {
2891 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2892 where
2893 D: serde::Deserializer<'de>,
2894 {
2895 struct GeneratedVisitor;
2896
2897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2898 type Value = GeneratedField;
2899
2900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2901 write!(formatter, "expected one of: {:?}", &FIELDS)
2902 }
2903
2904 #[allow(unused_variables)]
2905 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2906 where
2907 E: serde::de::Error,
2908 {
2909 Err(serde::de::Error::unknown_field(value, FIELDS))
2910 }
2911 }
2912 deserializer.deserialize_identifier(GeneratedVisitor)
2913 }
2914 }
2915 struct GeneratedVisitor;
2916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2917 type Value = DisableCommitEpochRequest;
2918
2919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2920 formatter.write_str("struct hummock.DisableCommitEpochRequest")
2921 }
2922
2923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochRequest, V::Error>
2924 where
2925 V: serde::de::MapAccess<'de>,
2926 {
2927 while map_.next_key::<GeneratedField>()?.is_some() {
2928 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2929 }
2930 Ok(DisableCommitEpochRequest {
2931 })
2932 }
2933 }
2934 deserializer.deserialize_struct("hummock.DisableCommitEpochRequest", FIELDS, GeneratedVisitor)
2935 }
2936}
2937impl serde::Serialize for DisableCommitEpochResponse {
2938 #[allow(deprecated)]
2939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2940 where
2941 S: serde::Serializer,
2942 {
2943 use serde::ser::SerializeStruct;
2944 let mut len = 0;
2945 if self.current_version.is_some() {
2946 len += 1;
2947 }
2948 let mut struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochResponse", len)?;
2949 if let Some(v) = self.current_version.as_ref() {
2950 struct_ser.serialize_field("currentVersion", v)?;
2951 }
2952 struct_ser.end()
2953 }
2954}
2955impl<'de> serde::Deserialize<'de> for DisableCommitEpochResponse {
2956 #[allow(deprecated)]
2957 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2958 where
2959 D: serde::Deserializer<'de>,
2960 {
2961 const FIELDS: &[&str] = &[
2962 "current_version",
2963 "currentVersion",
2964 ];
2965
2966 #[allow(clippy::enum_variant_names)]
2967 enum GeneratedField {
2968 CurrentVersion,
2969 }
2970 impl<'de> serde::Deserialize<'de> for GeneratedField {
2971 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2972 where
2973 D: serde::Deserializer<'de>,
2974 {
2975 struct GeneratedVisitor;
2976
2977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2978 type Value = GeneratedField;
2979
2980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2981 write!(formatter, "expected one of: {:?}", &FIELDS)
2982 }
2983
2984 #[allow(unused_variables)]
2985 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2986 where
2987 E: serde::de::Error,
2988 {
2989 match value {
2990 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
2991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2992 }
2993 }
2994 }
2995 deserializer.deserialize_identifier(GeneratedVisitor)
2996 }
2997 }
2998 struct GeneratedVisitor;
2999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3000 type Value = DisableCommitEpochResponse;
3001
3002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3003 formatter.write_str("struct hummock.DisableCommitEpochResponse")
3004 }
3005
3006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochResponse, V::Error>
3007 where
3008 V: serde::de::MapAccess<'de>,
3009 {
3010 let mut current_version__ = None;
3011 while let Some(k) = map_.next_key()? {
3012 match k {
3013 GeneratedField::CurrentVersion => {
3014 if current_version__.is_some() {
3015 return Err(serde::de::Error::duplicate_field("currentVersion"));
3016 }
3017 current_version__ = map_.next_value()?;
3018 }
3019 }
3020 }
3021 Ok(DisableCommitEpochResponse {
3022 current_version: current_version__,
3023 })
3024 }
3025 }
3026 deserializer.deserialize_struct("hummock.DisableCommitEpochResponse", FIELDS, GeneratedVisitor)
3027 }
3028}
3029impl serde::Serialize for EpochNewChangeLog {
3030 #[allow(deprecated)]
3031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3032 where
3033 S: serde::Serializer,
3034 {
3035 use serde::ser::SerializeStruct;
3036 let mut len = 0;
3037 if !self.old_value.is_empty() {
3038 len += 1;
3039 }
3040 if !self.new_value.is_empty() {
3041 len += 1;
3042 }
3043 if !self.epochs.is_empty() {
3044 len += 1;
3045 }
3046 let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3047 if !self.old_value.is_empty() {
3048 struct_ser.serialize_field("oldValue", &self.old_value)?;
3049 }
3050 if !self.new_value.is_empty() {
3051 struct_ser.serialize_field("newValue", &self.new_value)?;
3052 }
3053 if !self.epochs.is_empty() {
3054 struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3055 }
3056 struct_ser.end()
3057 }
3058}
3059impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3060 #[allow(deprecated)]
3061 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3062 where
3063 D: serde::Deserializer<'de>,
3064 {
3065 const FIELDS: &[&str] = &[
3066 "old_value",
3067 "oldValue",
3068 "new_value",
3069 "newValue",
3070 "epochs",
3071 ];
3072
3073 #[allow(clippy::enum_variant_names)]
3074 enum GeneratedField {
3075 OldValue,
3076 NewValue,
3077 Epochs,
3078 }
3079 impl<'de> serde::Deserialize<'de> for GeneratedField {
3080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3081 where
3082 D: serde::Deserializer<'de>,
3083 {
3084 struct GeneratedVisitor;
3085
3086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3087 type Value = GeneratedField;
3088
3089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3090 write!(formatter, "expected one of: {:?}", &FIELDS)
3091 }
3092
3093 #[allow(unused_variables)]
3094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3095 where
3096 E: serde::de::Error,
3097 {
3098 match value {
3099 "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3100 "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3101 "epochs" => Ok(GeneratedField::Epochs),
3102 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3103 }
3104 }
3105 }
3106 deserializer.deserialize_identifier(GeneratedVisitor)
3107 }
3108 }
3109 struct GeneratedVisitor;
3110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3111 type Value = EpochNewChangeLog;
3112
3113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3114 formatter.write_str("struct hummock.EpochNewChangeLog")
3115 }
3116
3117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3118 where
3119 V: serde::de::MapAccess<'de>,
3120 {
3121 let mut old_value__ = None;
3122 let mut new_value__ = None;
3123 let mut epochs__ = None;
3124 while let Some(k) = map_.next_key()? {
3125 match k {
3126 GeneratedField::OldValue => {
3127 if old_value__.is_some() {
3128 return Err(serde::de::Error::duplicate_field("oldValue"));
3129 }
3130 old_value__ = Some(map_.next_value()?);
3131 }
3132 GeneratedField::NewValue => {
3133 if new_value__.is_some() {
3134 return Err(serde::de::Error::duplicate_field("newValue"));
3135 }
3136 new_value__ = Some(map_.next_value()?);
3137 }
3138 GeneratedField::Epochs => {
3139 if epochs__.is_some() {
3140 return Err(serde::de::Error::duplicate_field("epochs"));
3141 }
3142 epochs__ =
3143 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3144 .into_iter().map(|x| x.0).collect())
3145 ;
3146 }
3147 }
3148 }
3149 Ok(EpochNewChangeLog {
3150 old_value: old_value__.unwrap_or_default(),
3151 new_value: new_value__.unwrap_or_default(),
3152 epochs: epochs__.unwrap_or_default(),
3153 })
3154 }
3155 }
3156 deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3157 }
3158}
3159impl serde::Serialize for FlatIndex {
3160 #[allow(deprecated)]
3161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3162 where
3163 S: serde::Serializer,
3164 {
3165 use serde::ser::SerializeStruct;
3166 let mut len = 0;
3167 if self.config.is_some() {
3168 len += 1;
3169 }
3170 if !self.vector_files.is_empty() {
3171 len += 1;
3172 }
3173 if self.next_vector_id != 0 {
3174 len += 1;
3175 }
3176 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3177 if let Some(v) = self.config.as_ref() {
3178 struct_ser.serialize_field("config", v)?;
3179 }
3180 if !self.vector_files.is_empty() {
3181 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3182 }
3183 if self.next_vector_id != 0 {
3184 #[allow(clippy::needless_borrow)]
3185 #[allow(clippy::needless_borrows_for_generic_args)]
3186 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3187 }
3188 struct_ser.end()
3189 }
3190}
3191impl<'de> serde::Deserialize<'de> for FlatIndex {
3192 #[allow(deprecated)]
3193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3194 where
3195 D: serde::Deserializer<'de>,
3196 {
3197 const FIELDS: &[&str] = &[
3198 "config",
3199 "vector_files",
3200 "vectorFiles",
3201 "next_vector_id",
3202 "nextVectorId",
3203 ];
3204
3205 #[allow(clippy::enum_variant_names)]
3206 enum GeneratedField {
3207 Config,
3208 VectorFiles,
3209 NextVectorId,
3210 }
3211 impl<'de> serde::Deserialize<'de> for GeneratedField {
3212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3213 where
3214 D: serde::Deserializer<'de>,
3215 {
3216 struct GeneratedVisitor;
3217
3218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3219 type Value = GeneratedField;
3220
3221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3222 write!(formatter, "expected one of: {:?}", &FIELDS)
3223 }
3224
3225 #[allow(unused_variables)]
3226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3227 where
3228 E: serde::de::Error,
3229 {
3230 match value {
3231 "config" => Ok(GeneratedField::Config),
3232 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3233 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3234 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3235 }
3236 }
3237 }
3238 deserializer.deserialize_identifier(GeneratedVisitor)
3239 }
3240 }
3241 struct GeneratedVisitor;
3242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3243 type Value = FlatIndex;
3244
3245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3246 formatter.write_str("struct hummock.FlatIndex")
3247 }
3248
3249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3250 where
3251 V: serde::de::MapAccess<'de>,
3252 {
3253 let mut config__ = None;
3254 let mut vector_files__ = None;
3255 let mut next_vector_id__ = None;
3256 while let Some(k) = map_.next_key()? {
3257 match k {
3258 GeneratedField::Config => {
3259 if config__.is_some() {
3260 return Err(serde::de::Error::duplicate_field("config"));
3261 }
3262 config__ = map_.next_value()?;
3263 }
3264 GeneratedField::VectorFiles => {
3265 if vector_files__.is_some() {
3266 return Err(serde::de::Error::duplicate_field("vectorFiles"));
3267 }
3268 vector_files__ = Some(map_.next_value()?);
3269 }
3270 GeneratedField::NextVectorId => {
3271 if next_vector_id__.is_some() {
3272 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3273 }
3274 next_vector_id__ =
3275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3276 ;
3277 }
3278 }
3279 }
3280 Ok(FlatIndex {
3281 config: config__,
3282 vector_files: vector_files__.unwrap_or_default(),
3283 next_vector_id: next_vector_id__.unwrap_or_default(),
3284 })
3285 }
3286 }
3287 deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3288 }
3289}
3290impl serde::Serialize for FlatIndexAdd {
3291 #[allow(deprecated)]
3292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3293 where
3294 S: serde::Serializer,
3295 {
3296 use serde::ser::SerializeStruct;
3297 let mut len = 0;
3298 if !self.added_vector_files.is_empty() {
3299 len += 1;
3300 }
3301 if self.next_vector_id != 0 {
3302 len += 1;
3303 }
3304 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3305 if !self.added_vector_files.is_empty() {
3306 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3307 }
3308 if self.next_vector_id != 0 {
3309 #[allow(clippy::needless_borrow)]
3310 #[allow(clippy::needless_borrows_for_generic_args)]
3311 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3312 }
3313 struct_ser.end()
3314 }
3315}
3316impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3317 #[allow(deprecated)]
3318 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3319 where
3320 D: serde::Deserializer<'de>,
3321 {
3322 const FIELDS: &[&str] = &[
3323 "added_vector_files",
3324 "addedVectorFiles",
3325 "next_vector_id",
3326 "nextVectorId",
3327 ];
3328
3329 #[allow(clippy::enum_variant_names)]
3330 enum GeneratedField {
3331 AddedVectorFiles,
3332 NextVectorId,
3333 }
3334 impl<'de> serde::Deserialize<'de> for GeneratedField {
3335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3336 where
3337 D: serde::Deserializer<'de>,
3338 {
3339 struct GeneratedVisitor;
3340
3341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3342 type Value = GeneratedField;
3343
3344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3345 write!(formatter, "expected one of: {:?}", &FIELDS)
3346 }
3347
3348 #[allow(unused_variables)]
3349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3350 where
3351 E: serde::de::Error,
3352 {
3353 match value {
3354 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3355 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3356 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3357 }
3358 }
3359 }
3360 deserializer.deserialize_identifier(GeneratedVisitor)
3361 }
3362 }
3363 struct GeneratedVisitor;
3364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3365 type Value = FlatIndexAdd;
3366
3367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3368 formatter.write_str("struct hummock.FlatIndexAdd")
3369 }
3370
3371 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3372 where
3373 V: serde::de::MapAccess<'de>,
3374 {
3375 let mut added_vector_files__ = None;
3376 let mut next_vector_id__ = None;
3377 while let Some(k) = map_.next_key()? {
3378 match k {
3379 GeneratedField::AddedVectorFiles => {
3380 if added_vector_files__.is_some() {
3381 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3382 }
3383 added_vector_files__ = Some(map_.next_value()?);
3384 }
3385 GeneratedField::NextVectorId => {
3386 if next_vector_id__.is_some() {
3387 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3388 }
3389 next_vector_id__ =
3390 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3391 ;
3392 }
3393 }
3394 }
3395 Ok(FlatIndexAdd {
3396 added_vector_files: added_vector_files__.unwrap_or_default(),
3397 next_vector_id: next_vector_id__.unwrap_or_default(),
3398 })
3399 }
3400 }
3401 deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3402 }
3403}
3404impl serde::Serialize for FullScanTask {
3405 #[allow(deprecated)]
3406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3407 where
3408 S: serde::Serializer,
3409 {
3410 use serde::ser::SerializeStruct;
3411 let mut len = 0;
3412 if self.sst_retention_watermark != 0 {
3413 len += 1;
3414 }
3415 if self.prefix.is_some() {
3416 len += 1;
3417 }
3418 if self.start_after.is_some() {
3419 len += 1;
3420 }
3421 if self.limit.is_some() {
3422 len += 1;
3423 }
3424 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3425 if self.sst_retention_watermark != 0 {
3426 #[allow(clippy::needless_borrow)]
3427 #[allow(clippy::needless_borrows_for_generic_args)]
3428 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3429 }
3430 if let Some(v) = self.prefix.as_ref() {
3431 struct_ser.serialize_field("prefix", v)?;
3432 }
3433 if let Some(v) = self.start_after.as_ref() {
3434 struct_ser.serialize_field("startAfter", v)?;
3435 }
3436 if let Some(v) = self.limit.as_ref() {
3437 #[allow(clippy::needless_borrow)]
3438 #[allow(clippy::needless_borrows_for_generic_args)]
3439 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3440 }
3441 struct_ser.end()
3442 }
3443}
3444impl<'de> serde::Deserialize<'de> for FullScanTask {
3445 #[allow(deprecated)]
3446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3447 where
3448 D: serde::Deserializer<'de>,
3449 {
3450 const FIELDS: &[&str] = &[
3451 "sst_retention_watermark",
3452 "sstRetentionWatermark",
3453 "prefix",
3454 "start_after",
3455 "startAfter",
3456 "limit",
3457 ];
3458
3459 #[allow(clippy::enum_variant_names)]
3460 enum GeneratedField {
3461 SstRetentionWatermark,
3462 Prefix,
3463 StartAfter,
3464 Limit,
3465 }
3466 impl<'de> serde::Deserialize<'de> for GeneratedField {
3467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3468 where
3469 D: serde::Deserializer<'de>,
3470 {
3471 struct GeneratedVisitor;
3472
3473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3474 type Value = GeneratedField;
3475
3476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3477 write!(formatter, "expected one of: {:?}", &FIELDS)
3478 }
3479
3480 #[allow(unused_variables)]
3481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3482 where
3483 E: serde::de::Error,
3484 {
3485 match value {
3486 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3487 "prefix" => Ok(GeneratedField::Prefix),
3488 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3489 "limit" => Ok(GeneratedField::Limit),
3490 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3491 }
3492 }
3493 }
3494 deserializer.deserialize_identifier(GeneratedVisitor)
3495 }
3496 }
3497 struct GeneratedVisitor;
3498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3499 type Value = FullScanTask;
3500
3501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3502 formatter.write_str("struct hummock.FullScanTask")
3503 }
3504
3505 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3506 where
3507 V: serde::de::MapAccess<'de>,
3508 {
3509 let mut sst_retention_watermark__ = None;
3510 let mut prefix__ = None;
3511 let mut start_after__ = None;
3512 let mut limit__ = None;
3513 while let Some(k) = map_.next_key()? {
3514 match k {
3515 GeneratedField::SstRetentionWatermark => {
3516 if sst_retention_watermark__.is_some() {
3517 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3518 }
3519 sst_retention_watermark__ =
3520 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3521 ;
3522 }
3523 GeneratedField::Prefix => {
3524 if prefix__.is_some() {
3525 return Err(serde::de::Error::duplicate_field("prefix"));
3526 }
3527 prefix__ = map_.next_value()?;
3528 }
3529 GeneratedField::StartAfter => {
3530 if start_after__.is_some() {
3531 return Err(serde::de::Error::duplicate_field("startAfter"));
3532 }
3533 start_after__ = map_.next_value()?;
3534 }
3535 GeneratedField::Limit => {
3536 if limit__.is_some() {
3537 return Err(serde::de::Error::duplicate_field("limit"));
3538 }
3539 limit__ =
3540 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3541 ;
3542 }
3543 }
3544 }
3545 Ok(FullScanTask {
3546 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3547 prefix: prefix__,
3548 start_after: start_after__,
3549 limit: limit__,
3550 })
3551 }
3552 }
3553 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3554 }
3555}
3556impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3557 #[allow(deprecated)]
3558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3559 where
3560 S: serde::Serializer,
3561 {
3562 use serde::ser::SerializeStruct;
3563 let len = 0;
3564 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3565 struct_ser.end()
3566 }
3567}
3568impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3569 #[allow(deprecated)]
3570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3571 where
3572 D: serde::Deserializer<'de>,
3573 {
3574 const FIELDS: &[&str] = &[
3575 ];
3576
3577 #[allow(clippy::enum_variant_names)]
3578 enum GeneratedField {
3579 }
3580 impl<'de> serde::Deserialize<'de> for GeneratedField {
3581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3582 where
3583 D: serde::Deserializer<'de>,
3584 {
3585 struct GeneratedVisitor;
3586
3587 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3588 type Value = GeneratedField;
3589
3590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3591 write!(formatter, "expected one of: {:?}", &FIELDS)
3592 }
3593
3594 #[allow(unused_variables)]
3595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3596 where
3597 E: serde::de::Error,
3598 {
3599 Err(serde::de::Error::unknown_field(value, FIELDS))
3600 }
3601 }
3602 deserializer.deserialize_identifier(GeneratedVisitor)
3603 }
3604 }
3605 struct GeneratedVisitor;
3606 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3607 type Value = GetAssignedCompactTaskNumRequest;
3608
3609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3610 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3611 }
3612
3613 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3614 where
3615 V: serde::de::MapAccess<'de>,
3616 {
3617 while map_.next_key::<GeneratedField>()?.is_some() {
3618 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3619 }
3620 Ok(GetAssignedCompactTaskNumRequest {
3621 })
3622 }
3623 }
3624 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3625 }
3626}
3627impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3628 #[allow(deprecated)]
3629 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3630 where
3631 S: serde::Serializer,
3632 {
3633 use serde::ser::SerializeStruct;
3634 let mut len = 0;
3635 if self.num_tasks != 0 {
3636 len += 1;
3637 }
3638 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3639 if self.num_tasks != 0 {
3640 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3641 }
3642 struct_ser.end()
3643 }
3644}
3645impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3646 #[allow(deprecated)]
3647 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3648 where
3649 D: serde::Deserializer<'de>,
3650 {
3651 const FIELDS: &[&str] = &[
3652 "num_tasks",
3653 "numTasks",
3654 ];
3655
3656 #[allow(clippy::enum_variant_names)]
3657 enum GeneratedField {
3658 NumTasks,
3659 }
3660 impl<'de> serde::Deserialize<'de> for GeneratedField {
3661 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3662 where
3663 D: serde::Deserializer<'de>,
3664 {
3665 struct GeneratedVisitor;
3666
3667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3668 type Value = GeneratedField;
3669
3670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3671 write!(formatter, "expected one of: {:?}", &FIELDS)
3672 }
3673
3674 #[allow(unused_variables)]
3675 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3676 where
3677 E: serde::de::Error,
3678 {
3679 match value {
3680 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3681 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3682 }
3683 }
3684 }
3685 deserializer.deserialize_identifier(GeneratedVisitor)
3686 }
3687 }
3688 struct GeneratedVisitor;
3689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3690 type Value = GetAssignedCompactTaskNumResponse;
3691
3692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3693 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3694 }
3695
3696 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3697 where
3698 V: serde::de::MapAccess<'de>,
3699 {
3700 let mut num_tasks__ = None;
3701 while let Some(k) = map_.next_key()? {
3702 match k {
3703 GeneratedField::NumTasks => {
3704 if num_tasks__.is_some() {
3705 return Err(serde::de::Error::duplicate_field("numTasks"));
3706 }
3707 num_tasks__ =
3708 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3709 ;
3710 }
3711 }
3712 }
3713 Ok(GetAssignedCompactTaskNumResponse {
3714 num_tasks: num_tasks__.unwrap_or_default(),
3715 })
3716 }
3717 }
3718 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3719 }
3720}
3721impl serde::Serialize for GetCompactionScoreRequest {
3722 #[allow(deprecated)]
3723 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3724 where
3725 S: serde::Serializer,
3726 {
3727 use serde::ser::SerializeStruct;
3728 let mut len = 0;
3729 if self.compaction_group_id != 0 {
3730 len += 1;
3731 }
3732 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3733 if self.compaction_group_id != 0 {
3734 #[allow(clippy::needless_borrow)]
3735 #[allow(clippy::needless_borrows_for_generic_args)]
3736 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3737 }
3738 struct_ser.end()
3739 }
3740}
3741impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3742 #[allow(deprecated)]
3743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3744 where
3745 D: serde::Deserializer<'de>,
3746 {
3747 const FIELDS: &[&str] = &[
3748 "compaction_group_id",
3749 "compactionGroupId",
3750 ];
3751
3752 #[allow(clippy::enum_variant_names)]
3753 enum GeneratedField {
3754 CompactionGroupId,
3755 }
3756 impl<'de> serde::Deserialize<'de> for GeneratedField {
3757 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3758 where
3759 D: serde::Deserializer<'de>,
3760 {
3761 struct GeneratedVisitor;
3762
3763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3764 type Value = GeneratedField;
3765
3766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3767 write!(formatter, "expected one of: {:?}", &FIELDS)
3768 }
3769
3770 #[allow(unused_variables)]
3771 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3772 where
3773 E: serde::de::Error,
3774 {
3775 match value {
3776 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3778 }
3779 }
3780 }
3781 deserializer.deserialize_identifier(GeneratedVisitor)
3782 }
3783 }
3784 struct GeneratedVisitor;
3785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3786 type Value = GetCompactionScoreRequest;
3787
3788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3789 formatter.write_str("struct hummock.GetCompactionScoreRequest")
3790 }
3791
3792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3793 where
3794 V: serde::de::MapAccess<'de>,
3795 {
3796 let mut compaction_group_id__ = None;
3797 while let Some(k) = map_.next_key()? {
3798 match k {
3799 GeneratedField::CompactionGroupId => {
3800 if compaction_group_id__.is_some() {
3801 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3802 }
3803 compaction_group_id__ =
3804 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3805 ;
3806 }
3807 }
3808 }
3809 Ok(GetCompactionScoreRequest {
3810 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3811 })
3812 }
3813 }
3814 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
3815 }
3816}
3817impl serde::Serialize for GetCompactionScoreResponse {
3818 #[allow(deprecated)]
3819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3820 where
3821 S: serde::Serializer,
3822 {
3823 use serde::ser::SerializeStruct;
3824 let mut len = 0;
3825 if self.compaction_group_id != 0 {
3826 len += 1;
3827 }
3828 if !self.scores.is_empty() {
3829 len += 1;
3830 }
3831 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
3832 if self.compaction_group_id != 0 {
3833 #[allow(clippy::needless_borrow)]
3834 #[allow(clippy::needless_borrows_for_generic_args)]
3835 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3836 }
3837 if !self.scores.is_empty() {
3838 struct_ser.serialize_field("scores", &self.scores)?;
3839 }
3840 struct_ser.end()
3841 }
3842}
3843impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
3844 #[allow(deprecated)]
3845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3846 where
3847 D: serde::Deserializer<'de>,
3848 {
3849 const FIELDS: &[&str] = &[
3850 "compaction_group_id",
3851 "compactionGroupId",
3852 "scores",
3853 ];
3854
3855 #[allow(clippy::enum_variant_names)]
3856 enum GeneratedField {
3857 CompactionGroupId,
3858 Scores,
3859 }
3860 impl<'de> serde::Deserialize<'de> for GeneratedField {
3861 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3862 where
3863 D: serde::Deserializer<'de>,
3864 {
3865 struct GeneratedVisitor;
3866
3867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3868 type Value = GeneratedField;
3869
3870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3871 write!(formatter, "expected one of: {:?}", &FIELDS)
3872 }
3873
3874 #[allow(unused_variables)]
3875 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3876 where
3877 E: serde::de::Error,
3878 {
3879 match value {
3880 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3881 "scores" => Ok(GeneratedField::Scores),
3882 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3883 }
3884 }
3885 }
3886 deserializer.deserialize_identifier(GeneratedVisitor)
3887 }
3888 }
3889 struct GeneratedVisitor;
3890 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3891 type Value = GetCompactionScoreResponse;
3892
3893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3894 formatter.write_str("struct hummock.GetCompactionScoreResponse")
3895 }
3896
3897 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
3898 where
3899 V: serde::de::MapAccess<'de>,
3900 {
3901 let mut compaction_group_id__ = None;
3902 let mut scores__ = None;
3903 while let Some(k) = map_.next_key()? {
3904 match k {
3905 GeneratedField::CompactionGroupId => {
3906 if compaction_group_id__.is_some() {
3907 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3908 }
3909 compaction_group_id__ =
3910 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3911 ;
3912 }
3913 GeneratedField::Scores => {
3914 if scores__.is_some() {
3915 return Err(serde::de::Error::duplicate_field("scores"));
3916 }
3917 scores__ = Some(map_.next_value()?);
3918 }
3919 }
3920 }
3921 Ok(GetCompactionScoreResponse {
3922 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3923 scores: scores__.unwrap_or_default(),
3924 })
3925 }
3926 }
3927 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
3928 }
3929}
3930impl serde::Serialize for get_compaction_score_response::PickerInfo {
3931 #[allow(deprecated)]
3932 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3933 where
3934 S: serde::Serializer,
3935 {
3936 use serde::ser::SerializeStruct;
3937 let mut len = 0;
3938 if self.score != 0 {
3939 len += 1;
3940 }
3941 if self.select_level != 0 {
3942 len += 1;
3943 }
3944 if self.target_level != 0 {
3945 len += 1;
3946 }
3947 if !self.picker_type.is_empty() {
3948 len += 1;
3949 }
3950 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
3951 if self.score != 0 {
3952 #[allow(clippy::needless_borrow)]
3953 #[allow(clippy::needless_borrows_for_generic_args)]
3954 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
3955 }
3956 if self.select_level != 0 {
3957 #[allow(clippy::needless_borrow)]
3958 #[allow(clippy::needless_borrows_for_generic_args)]
3959 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
3960 }
3961 if self.target_level != 0 {
3962 #[allow(clippy::needless_borrow)]
3963 #[allow(clippy::needless_borrows_for_generic_args)]
3964 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
3965 }
3966 if !self.picker_type.is_empty() {
3967 struct_ser.serialize_field("pickerType", &self.picker_type)?;
3968 }
3969 struct_ser.end()
3970 }
3971}
3972impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
3973 #[allow(deprecated)]
3974 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3975 where
3976 D: serde::Deserializer<'de>,
3977 {
3978 const FIELDS: &[&str] = &[
3979 "score",
3980 "select_level",
3981 "selectLevel",
3982 "target_level",
3983 "targetLevel",
3984 "picker_type",
3985 "pickerType",
3986 ];
3987
3988 #[allow(clippy::enum_variant_names)]
3989 enum GeneratedField {
3990 Score,
3991 SelectLevel,
3992 TargetLevel,
3993 PickerType,
3994 }
3995 impl<'de> serde::Deserialize<'de> for GeneratedField {
3996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3997 where
3998 D: serde::Deserializer<'de>,
3999 {
4000 struct GeneratedVisitor;
4001
4002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4003 type Value = GeneratedField;
4004
4005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4006 write!(formatter, "expected one of: {:?}", &FIELDS)
4007 }
4008
4009 #[allow(unused_variables)]
4010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4011 where
4012 E: serde::de::Error,
4013 {
4014 match value {
4015 "score" => Ok(GeneratedField::Score),
4016 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4017 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4018 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4019 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4020 }
4021 }
4022 }
4023 deserializer.deserialize_identifier(GeneratedVisitor)
4024 }
4025 }
4026 struct GeneratedVisitor;
4027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4028 type Value = get_compaction_score_response::PickerInfo;
4029
4030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4031 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4032 }
4033
4034 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4035 where
4036 V: serde::de::MapAccess<'de>,
4037 {
4038 let mut score__ = None;
4039 let mut select_level__ = None;
4040 let mut target_level__ = None;
4041 let mut picker_type__ = None;
4042 while let Some(k) = map_.next_key()? {
4043 match k {
4044 GeneratedField::Score => {
4045 if score__.is_some() {
4046 return Err(serde::de::Error::duplicate_field("score"));
4047 }
4048 score__ =
4049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4050 ;
4051 }
4052 GeneratedField::SelectLevel => {
4053 if select_level__.is_some() {
4054 return Err(serde::de::Error::duplicate_field("selectLevel"));
4055 }
4056 select_level__ =
4057 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4058 ;
4059 }
4060 GeneratedField::TargetLevel => {
4061 if target_level__.is_some() {
4062 return Err(serde::de::Error::duplicate_field("targetLevel"));
4063 }
4064 target_level__ =
4065 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4066 ;
4067 }
4068 GeneratedField::PickerType => {
4069 if picker_type__.is_some() {
4070 return Err(serde::de::Error::duplicate_field("pickerType"));
4071 }
4072 picker_type__ = Some(map_.next_value()?);
4073 }
4074 }
4075 }
4076 Ok(get_compaction_score_response::PickerInfo {
4077 score: score__.unwrap_or_default(),
4078 select_level: select_level__.unwrap_or_default(),
4079 target_level: target_level__.unwrap_or_default(),
4080 picker_type: picker_type__.unwrap_or_default(),
4081 })
4082 }
4083 }
4084 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4085 }
4086}
4087impl serde::Serialize for GetCurrentVersionRequest {
4088 #[allow(deprecated)]
4089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4090 where
4091 S: serde::Serializer,
4092 {
4093 use serde::ser::SerializeStruct;
4094 let len = 0;
4095 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4096 struct_ser.end()
4097 }
4098}
4099impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4100 #[allow(deprecated)]
4101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4102 where
4103 D: serde::Deserializer<'de>,
4104 {
4105 const FIELDS: &[&str] = &[
4106 ];
4107
4108 #[allow(clippy::enum_variant_names)]
4109 enum GeneratedField {
4110 }
4111 impl<'de> serde::Deserialize<'de> for GeneratedField {
4112 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4113 where
4114 D: serde::Deserializer<'de>,
4115 {
4116 struct GeneratedVisitor;
4117
4118 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4119 type Value = GeneratedField;
4120
4121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4122 write!(formatter, "expected one of: {:?}", &FIELDS)
4123 }
4124
4125 #[allow(unused_variables)]
4126 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4127 where
4128 E: serde::de::Error,
4129 {
4130 Err(serde::de::Error::unknown_field(value, FIELDS))
4131 }
4132 }
4133 deserializer.deserialize_identifier(GeneratedVisitor)
4134 }
4135 }
4136 struct GeneratedVisitor;
4137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4138 type Value = GetCurrentVersionRequest;
4139
4140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4141 formatter.write_str("struct hummock.GetCurrentVersionRequest")
4142 }
4143
4144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4145 where
4146 V: serde::de::MapAccess<'de>,
4147 {
4148 while map_.next_key::<GeneratedField>()?.is_some() {
4149 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4150 }
4151 Ok(GetCurrentVersionRequest {
4152 })
4153 }
4154 }
4155 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4156 }
4157}
4158impl serde::Serialize for GetCurrentVersionResponse {
4159 #[allow(deprecated)]
4160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4161 where
4162 S: serde::Serializer,
4163 {
4164 use serde::ser::SerializeStruct;
4165 let mut len = 0;
4166 if self.status.is_some() {
4167 len += 1;
4168 }
4169 if self.current_version.is_some() {
4170 len += 1;
4171 }
4172 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4173 if let Some(v) = self.status.as_ref() {
4174 struct_ser.serialize_field("status", v)?;
4175 }
4176 if let Some(v) = self.current_version.as_ref() {
4177 struct_ser.serialize_field("currentVersion", v)?;
4178 }
4179 struct_ser.end()
4180 }
4181}
4182impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4183 #[allow(deprecated)]
4184 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4185 where
4186 D: serde::Deserializer<'de>,
4187 {
4188 const FIELDS: &[&str] = &[
4189 "status",
4190 "current_version",
4191 "currentVersion",
4192 ];
4193
4194 #[allow(clippy::enum_variant_names)]
4195 enum GeneratedField {
4196 Status,
4197 CurrentVersion,
4198 }
4199 impl<'de> serde::Deserialize<'de> for GeneratedField {
4200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4201 where
4202 D: serde::Deserializer<'de>,
4203 {
4204 struct GeneratedVisitor;
4205
4206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4207 type Value = GeneratedField;
4208
4209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4210 write!(formatter, "expected one of: {:?}", &FIELDS)
4211 }
4212
4213 #[allow(unused_variables)]
4214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4215 where
4216 E: serde::de::Error,
4217 {
4218 match value {
4219 "status" => Ok(GeneratedField::Status),
4220 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4222 }
4223 }
4224 }
4225 deserializer.deserialize_identifier(GeneratedVisitor)
4226 }
4227 }
4228 struct GeneratedVisitor;
4229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4230 type Value = GetCurrentVersionResponse;
4231
4232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4233 formatter.write_str("struct hummock.GetCurrentVersionResponse")
4234 }
4235
4236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4237 where
4238 V: serde::de::MapAccess<'de>,
4239 {
4240 let mut status__ = None;
4241 let mut current_version__ = None;
4242 while let Some(k) = map_.next_key()? {
4243 match k {
4244 GeneratedField::Status => {
4245 if status__.is_some() {
4246 return Err(serde::de::Error::duplicate_field("status"));
4247 }
4248 status__ = map_.next_value()?;
4249 }
4250 GeneratedField::CurrentVersion => {
4251 if current_version__.is_some() {
4252 return Err(serde::de::Error::duplicate_field("currentVersion"));
4253 }
4254 current_version__ = map_.next_value()?;
4255 }
4256 }
4257 }
4258 Ok(GetCurrentVersionResponse {
4259 status: status__,
4260 current_version: current_version__,
4261 })
4262 }
4263 }
4264 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4265 }
4266}
4267impl serde::Serialize for GetNewObjectIdsRequest {
4268 #[allow(deprecated)]
4269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4270 where
4271 S: serde::Serializer,
4272 {
4273 use serde::ser::SerializeStruct;
4274 let mut len = 0;
4275 if self.number != 0 {
4276 len += 1;
4277 }
4278 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4279 if self.number != 0 {
4280 struct_ser.serialize_field("number", &self.number)?;
4281 }
4282 struct_ser.end()
4283 }
4284}
4285impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4286 #[allow(deprecated)]
4287 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4288 where
4289 D: serde::Deserializer<'de>,
4290 {
4291 const FIELDS: &[&str] = &[
4292 "number",
4293 ];
4294
4295 #[allow(clippy::enum_variant_names)]
4296 enum GeneratedField {
4297 Number,
4298 }
4299 impl<'de> serde::Deserialize<'de> for GeneratedField {
4300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4301 where
4302 D: serde::Deserializer<'de>,
4303 {
4304 struct GeneratedVisitor;
4305
4306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4307 type Value = GeneratedField;
4308
4309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4310 write!(formatter, "expected one of: {:?}", &FIELDS)
4311 }
4312
4313 #[allow(unused_variables)]
4314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4315 where
4316 E: serde::de::Error,
4317 {
4318 match value {
4319 "number" => Ok(GeneratedField::Number),
4320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4321 }
4322 }
4323 }
4324 deserializer.deserialize_identifier(GeneratedVisitor)
4325 }
4326 }
4327 struct GeneratedVisitor;
4328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4329 type Value = GetNewObjectIdsRequest;
4330
4331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4332 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4333 }
4334
4335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4336 where
4337 V: serde::de::MapAccess<'de>,
4338 {
4339 let mut number__ = None;
4340 while let Some(k) = map_.next_key()? {
4341 match k {
4342 GeneratedField::Number => {
4343 if number__.is_some() {
4344 return Err(serde::de::Error::duplicate_field("number"));
4345 }
4346 number__ =
4347 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4348 ;
4349 }
4350 }
4351 }
4352 Ok(GetNewObjectIdsRequest {
4353 number: number__.unwrap_or_default(),
4354 })
4355 }
4356 }
4357 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4358 }
4359}
4360impl serde::Serialize for GetNewObjectIdsResponse {
4361 #[allow(deprecated)]
4362 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4363 where
4364 S: serde::Serializer,
4365 {
4366 use serde::ser::SerializeStruct;
4367 let mut len = 0;
4368 if self.status.is_some() {
4369 len += 1;
4370 }
4371 if self.start_id != 0 {
4372 len += 1;
4373 }
4374 if self.end_id != 0 {
4375 len += 1;
4376 }
4377 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4378 if let Some(v) = self.status.as_ref() {
4379 struct_ser.serialize_field("status", v)?;
4380 }
4381 if self.start_id != 0 {
4382 #[allow(clippy::needless_borrow)]
4383 #[allow(clippy::needless_borrows_for_generic_args)]
4384 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4385 }
4386 if self.end_id != 0 {
4387 #[allow(clippy::needless_borrow)]
4388 #[allow(clippy::needless_borrows_for_generic_args)]
4389 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4390 }
4391 struct_ser.end()
4392 }
4393}
4394impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4395 #[allow(deprecated)]
4396 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4397 where
4398 D: serde::Deserializer<'de>,
4399 {
4400 const FIELDS: &[&str] = &[
4401 "status",
4402 "start_id",
4403 "startId",
4404 "end_id",
4405 "endId",
4406 ];
4407
4408 #[allow(clippy::enum_variant_names)]
4409 enum GeneratedField {
4410 Status,
4411 StartId,
4412 EndId,
4413 }
4414 impl<'de> serde::Deserialize<'de> for GeneratedField {
4415 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4416 where
4417 D: serde::Deserializer<'de>,
4418 {
4419 struct GeneratedVisitor;
4420
4421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4422 type Value = GeneratedField;
4423
4424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4425 write!(formatter, "expected one of: {:?}", &FIELDS)
4426 }
4427
4428 #[allow(unused_variables)]
4429 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4430 where
4431 E: serde::de::Error,
4432 {
4433 match value {
4434 "status" => Ok(GeneratedField::Status),
4435 "startId" | "start_id" => Ok(GeneratedField::StartId),
4436 "endId" | "end_id" => Ok(GeneratedField::EndId),
4437 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4438 }
4439 }
4440 }
4441 deserializer.deserialize_identifier(GeneratedVisitor)
4442 }
4443 }
4444 struct GeneratedVisitor;
4445 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4446 type Value = GetNewObjectIdsResponse;
4447
4448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4449 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4450 }
4451
4452 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4453 where
4454 V: serde::de::MapAccess<'de>,
4455 {
4456 let mut status__ = None;
4457 let mut start_id__ = None;
4458 let mut end_id__ = None;
4459 while let Some(k) = map_.next_key()? {
4460 match k {
4461 GeneratedField::Status => {
4462 if status__.is_some() {
4463 return Err(serde::de::Error::duplicate_field("status"));
4464 }
4465 status__ = map_.next_value()?;
4466 }
4467 GeneratedField::StartId => {
4468 if start_id__.is_some() {
4469 return Err(serde::de::Error::duplicate_field("startId"));
4470 }
4471 start_id__ =
4472 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4473 ;
4474 }
4475 GeneratedField::EndId => {
4476 if end_id__.is_some() {
4477 return Err(serde::de::Error::duplicate_field("endId"));
4478 }
4479 end_id__ =
4480 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4481 ;
4482 }
4483 }
4484 }
4485 Ok(GetNewObjectIdsResponse {
4486 status: status__,
4487 start_id: start_id__.unwrap_or_default(),
4488 end_id: end_id__.unwrap_or_default(),
4489 })
4490 }
4491 }
4492 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4493 }
4494}
4495impl serde::Serialize for GetVersionByEpochRequest {
4496 #[allow(deprecated)]
4497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4498 where
4499 S: serde::Serializer,
4500 {
4501 use serde::ser::SerializeStruct;
4502 let mut len = 0;
4503 if self.epoch != 0 {
4504 len += 1;
4505 }
4506 if self.table_id != 0 {
4507 len += 1;
4508 }
4509 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
4510 if self.epoch != 0 {
4511 #[allow(clippy::needless_borrow)]
4512 #[allow(clippy::needless_borrows_for_generic_args)]
4513 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
4514 }
4515 if self.table_id != 0 {
4516 struct_ser.serialize_field("tableId", &self.table_id)?;
4517 }
4518 struct_ser.end()
4519 }
4520}
4521impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
4522 #[allow(deprecated)]
4523 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4524 where
4525 D: serde::Deserializer<'de>,
4526 {
4527 const FIELDS: &[&str] = &[
4528 "epoch",
4529 "table_id",
4530 "tableId",
4531 ];
4532
4533 #[allow(clippy::enum_variant_names)]
4534 enum GeneratedField {
4535 Epoch,
4536 TableId,
4537 }
4538 impl<'de> serde::Deserialize<'de> for GeneratedField {
4539 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4540 where
4541 D: serde::Deserializer<'de>,
4542 {
4543 struct GeneratedVisitor;
4544
4545 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4546 type Value = GeneratedField;
4547
4548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4549 write!(formatter, "expected one of: {:?}", &FIELDS)
4550 }
4551
4552 #[allow(unused_variables)]
4553 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4554 where
4555 E: serde::de::Error,
4556 {
4557 match value {
4558 "epoch" => Ok(GeneratedField::Epoch),
4559 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4561 }
4562 }
4563 }
4564 deserializer.deserialize_identifier(GeneratedVisitor)
4565 }
4566 }
4567 struct GeneratedVisitor;
4568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4569 type Value = GetVersionByEpochRequest;
4570
4571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4572 formatter.write_str("struct hummock.GetVersionByEpochRequest")
4573 }
4574
4575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
4576 where
4577 V: serde::de::MapAccess<'de>,
4578 {
4579 let mut epoch__ = None;
4580 let mut table_id__ = None;
4581 while let Some(k) = map_.next_key()? {
4582 match k {
4583 GeneratedField::Epoch => {
4584 if epoch__.is_some() {
4585 return Err(serde::de::Error::duplicate_field("epoch"));
4586 }
4587 epoch__ =
4588 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4589 ;
4590 }
4591 GeneratedField::TableId => {
4592 if table_id__.is_some() {
4593 return Err(serde::de::Error::duplicate_field("tableId"));
4594 }
4595 table_id__ =
4596 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4597 ;
4598 }
4599 }
4600 }
4601 Ok(GetVersionByEpochRequest {
4602 epoch: epoch__.unwrap_or_default(),
4603 table_id: table_id__.unwrap_or_default(),
4604 })
4605 }
4606 }
4607 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
4608 }
4609}
4610impl serde::Serialize for GetVersionByEpochResponse {
4611 #[allow(deprecated)]
4612 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4613 where
4614 S: serde::Serializer,
4615 {
4616 use serde::ser::SerializeStruct;
4617 let mut len = 0;
4618 if self.version.is_some() {
4619 len += 1;
4620 }
4621 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
4622 if let Some(v) = self.version.as_ref() {
4623 struct_ser.serialize_field("version", v)?;
4624 }
4625 struct_ser.end()
4626 }
4627}
4628impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
4629 #[allow(deprecated)]
4630 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4631 where
4632 D: serde::Deserializer<'de>,
4633 {
4634 const FIELDS: &[&str] = &[
4635 "version",
4636 ];
4637
4638 #[allow(clippy::enum_variant_names)]
4639 enum GeneratedField {
4640 Version,
4641 }
4642 impl<'de> serde::Deserialize<'de> for GeneratedField {
4643 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4644 where
4645 D: serde::Deserializer<'de>,
4646 {
4647 struct GeneratedVisitor;
4648
4649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4650 type Value = GeneratedField;
4651
4652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4653 write!(formatter, "expected one of: {:?}", &FIELDS)
4654 }
4655
4656 #[allow(unused_variables)]
4657 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4658 where
4659 E: serde::de::Error,
4660 {
4661 match value {
4662 "version" => Ok(GeneratedField::Version),
4663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4664 }
4665 }
4666 }
4667 deserializer.deserialize_identifier(GeneratedVisitor)
4668 }
4669 }
4670 struct GeneratedVisitor;
4671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4672 type Value = GetVersionByEpochResponse;
4673
4674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4675 formatter.write_str("struct hummock.GetVersionByEpochResponse")
4676 }
4677
4678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
4679 where
4680 V: serde::de::MapAccess<'de>,
4681 {
4682 let mut version__ = None;
4683 while let Some(k) = map_.next_key()? {
4684 match k {
4685 GeneratedField::Version => {
4686 if version__.is_some() {
4687 return Err(serde::de::Error::duplicate_field("version"));
4688 }
4689 version__ = map_.next_value()?;
4690 }
4691 }
4692 }
4693 Ok(GetVersionByEpochResponse {
4694 version: version__,
4695 })
4696 }
4697 }
4698 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
4699 }
4700}
4701impl serde::Serialize for GroupConstruct {
4702 #[allow(deprecated)]
4703 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4704 where
4705 S: serde::Serializer,
4706 {
4707 use serde::ser::SerializeStruct;
4708 let mut len = 0;
4709 if self.group_config.is_some() {
4710 len += 1;
4711 }
4712 if self.parent_group_id != 0 {
4713 len += 1;
4714 }
4715 if !self.table_ids.is_empty() {
4716 len += 1;
4717 }
4718 if self.group_id != 0 {
4719 len += 1;
4720 }
4721 if self.new_sst_start_id != 0 {
4722 len += 1;
4723 }
4724 if self.version != 0 {
4725 len += 1;
4726 }
4727 if self.split_key.is_some() {
4728 len += 1;
4729 }
4730 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
4731 if let Some(v) = self.group_config.as_ref() {
4732 struct_ser.serialize_field("groupConfig", v)?;
4733 }
4734 if self.parent_group_id != 0 {
4735 #[allow(clippy::needless_borrow)]
4736 #[allow(clippy::needless_borrows_for_generic_args)]
4737 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
4738 }
4739 if !self.table_ids.is_empty() {
4740 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4741 }
4742 if self.group_id != 0 {
4743 #[allow(clippy::needless_borrow)]
4744 #[allow(clippy::needless_borrows_for_generic_args)]
4745 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
4746 }
4747 if self.new_sst_start_id != 0 {
4748 #[allow(clippy::needless_borrow)]
4749 #[allow(clippy::needless_borrows_for_generic_args)]
4750 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
4751 }
4752 if self.version != 0 {
4753 let v = CompatibilityVersion::try_from(self.version)
4754 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4755 struct_ser.serialize_field("version", &v)?;
4756 }
4757 if let Some(v) = self.split_key.as_ref() {
4758 #[allow(clippy::needless_borrow)]
4759 #[allow(clippy::needless_borrows_for_generic_args)]
4760 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
4761 }
4762 struct_ser.end()
4763 }
4764}
4765impl<'de> serde::Deserialize<'de> for GroupConstruct {
4766 #[allow(deprecated)]
4767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4768 where
4769 D: serde::Deserializer<'de>,
4770 {
4771 const FIELDS: &[&str] = &[
4772 "group_config",
4773 "groupConfig",
4774 "parent_group_id",
4775 "parentGroupId",
4776 "table_ids",
4777 "tableIds",
4778 "group_id",
4779 "groupId",
4780 "new_sst_start_id",
4781 "newSstStartId",
4782 "version",
4783 "split_key",
4784 "splitKey",
4785 ];
4786
4787 #[allow(clippy::enum_variant_names)]
4788 enum GeneratedField {
4789 GroupConfig,
4790 ParentGroupId,
4791 TableIds,
4792 GroupId,
4793 NewSstStartId,
4794 Version,
4795 SplitKey,
4796 }
4797 impl<'de> serde::Deserialize<'de> for GeneratedField {
4798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4799 where
4800 D: serde::Deserializer<'de>,
4801 {
4802 struct GeneratedVisitor;
4803
4804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4805 type Value = GeneratedField;
4806
4807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4808 write!(formatter, "expected one of: {:?}", &FIELDS)
4809 }
4810
4811 #[allow(unused_variables)]
4812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4813 where
4814 E: serde::de::Error,
4815 {
4816 match value {
4817 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
4818 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
4819 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4820 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
4821 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
4822 "version" => Ok(GeneratedField::Version),
4823 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
4824 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4825 }
4826 }
4827 }
4828 deserializer.deserialize_identifier(GeneratedVisitor)
4829 }
4830 }
4831 struct GeneratedVisitor;
4832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4833 type Value = GroupConstruct;
4834
4835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4836 formatter.write_str("struct hummock.GroupConstruct")
4837 }
4838
4839 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
4840 where
4841 V: serde::de::MapAccess<'de>,
4842 {
4843 let mut group_config__ = None;
4844 let mut parent_group_id__ = None;
4845 let mut table_ids__ = None;
4846 let mut group_id__ = None;
4847 let mut new_sst_start_id__ = None;
4848 let mut version__ = None;
4849 let mut split_key__ = None;
4850 while let Some(k) = map_.next_key()? {
4851 match k {
4852 GeneratedField::GroupConfig => {
4853 if group_config__.is_some() {
4854 return Err(serde::de::Error::duplicate_field("groupConfig"));
4855 }
4856 group_config__ = map_.next_value()?;
4857 }
4858 GeneratedField::ParentGroupId => {
4859 if parent_group_id__.is_some() {
4860 return Err(serde::de::Error::duplicate_field("parentGroupId"));
4861 }
4862 parent_group_id__ =
4863 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4864 ;
4865 }
4866 GeneratedField::TableIds => {
4867 if table_ids__.is_some() {
4868 return Err(serde::de::Error::duplicate_field("tableIds"));
4869 }
4870 table_ids__ =
4871 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4872 .into_iter().map(|x| x.0).collect())
4873 ;
4874 }
4875 GeneratedField::GroupId => {
4876 if group_id__.is_some() {
4877 return Err(serde::de::Error::duplicate_field("groupId"));
4878 }
4879 group_id__ =
4880 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4881 ;
4882 }
4883 GeneratedField::NewSstStartId => {
4884 if new_sst_start_id__.is_some() {
4885 return Err(serde::de::Error::duplicate_field("newSstStartId"));
4886 }
4887 new_sst_start_id__ =
4888 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4889 ;
4890 }
4891 GeneratedField::Version => {
4892 if version__.is_some() {
4893 return Err(serde::de::Error::duplicate_field("version"));
4894 }
4895 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
4896 }
4897 GeneratedField::SplitKey => {
4898 if split_key__.is_some() {
4899 return Err(serde::de::Error::duplicate_field("splitKey"));
4900 }
4901 split_key__ =
4902 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
4903 ;
4904 }
4905 }
4906 }
4907 Ok(GroupConstruct {
4908 group_config: group_config__,
4909 parent_group_id: parent_group_id__.unwrap_or_default(),
4910 table_ids: table_ids__.unwrap_or_default(),
4911 group_id: group_id__.unwrap_or_default(),
4912 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
4913 version: version__.unwrap_or_default(),
4914 split_key: split_key__,
4915 })
4916 }
4917 }
4918 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
4919 }
4920}
4921impl serde::Serialize for GroupDelta {
4922 #[allow(deprecated)]
4923 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4924 where
4925 S: serde::Serializer,
4926 {
4927 use serde::ser::SerializeStruct;
4928 let mut len = 0;
4929 if self.delta_type.is_some() {
4930 len += 1;
4931 }
4932 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
4933 if let Some(v) = self.delta_type.as_ref() {
4934 match v {
4935 group_delta::DeltaType::IntraLevel(v) => {
4936 struct_ser.serialize_field("intraLevel", v)?;
4937 }
4938 group_delta::DeltaType::GroupConstruct(v) => {
4939 struct_ser.serialize_field("groupConstruct", v)?;
4940 }
4941 group_delta::DeltaType::GroupDestroy(v) => {
4942 struct_ser.serialize_field("groupDestroy", v)?;
4943 }
4944 group_delta::DeltaType::GroupMerge(v) => {
4945 struct_ser.serialize_field("groupMerge", v)?;
4946 }
4947 group_delta::DeltaType::NewL0SubLevel(v) => {
4948 struct_ser.serialize_field("newL0SubLevel", v)?;
4949 }
4950 group_delta::DeltaType::TruncateTables(v) => {
4951 struct_ser.serialize_field("truncateTables", v)?;
4952 }
4953 }
4954 }
4955 struct_ser.end()
4956 }
4957}
4958impl<'de> serde::Deserialize<'de> for GroupDelta {
4959 #[allow(deprecated)]
4960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4961 where
4962 D: serde::Deserializer<'de>,
4963 {
4964 const FIELDS: &[&str] = &[
4965 "intra_level",
4966 "intraLevel",
4967 "group_construct",
4968 "groupConstruct",
4969 "group_destroy",
4970 "groupDestroy",
4971 "group_merge",
4972 "groupMerge",
4973 "new_l0_sub_level",
4974 "newL0SubLevel",
4975 "truncate_tables",
4976 "truncateTables",
4977 ];
4978
4979 #[allow(clippy::enum_variant_names)]
4980 enum GeneratedField {
4981 IntraLevel,
4982 GroupConstruct,
4983 GroupDestroy,
4984 GroupMerge,
4985 NewL0SubLevel,
4986 TruncateTables,
4987 }
4988 impl<'de> serde::Deserialize<'de> for GeneratedField {
4989 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4990 where
4991 D: serde::Deserializer<'de>,
4992 {
4993 struct GeneratedVisitor;
4994
4995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4996 type Value = GeneratedField;
4997
4998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4999 write!(formatter, "expected one of: {:?}", &FIELDS)
5000 }
5001
5002 #[allow(unused_variables)]
5003 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5004 where
5005 E: serde::de::Error,
5006 {
5007 match value {
5008 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5009 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5010 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5011 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5012 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5013 "truncateTables" | "truncate_tables" => Ok(GeneratedField::TruncateTables),
5014 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5015 }
5016 }
5017 }
5018 deserializer.deserialize_identifier(GeneratedVisitor)
5019 }
5020 }
5021 struct GeneratedVisitor;
5022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5023 type Value = GroupDelta;
5024
5025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5026 formatter.write_str("struct hummock.GroupDelta")
5027 }
5028
5029 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5030 where
5031 V: serde::de::MapAccess<'de>,
5032 {
5033 let mut delta_type__ = None;
5034 while let Some(k) = map_.next_key()? {
5035 match k {
5036 GeneratedField::IntraLevel => {
5037 if delta_type__.is_some() {
5038 return Err(serde::de::Error::duplicate_field("intraLevel"));
5039 }
5040 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5041;
5042 }
5043 GeneratedField::GroupConstruct => {
5044 if delta_type__.is_some() {
5045 return Err(serde::de::Error::duplicate_field("groupConstruct"));
5046 }
5047 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5048;
5049 }
5050 GeneratedField::GroupDestroy => {
5051 if delta_type__.is_some() {
5052 return Err(serde::de::Error::duplicate_field("groupDestroy"));
5053 }
5054 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5055;
5056 }
5057 GeneratedField::GroupMerge => {
5058 if delta_type__.is_some() {
5059 return Err(serde::de::Error::duplicate_field("groupMerge"));
5060 }
5061 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5062;
5063 }
5064 GeneratedField::NewL0SubLevel => {
5065 if delta_type__.is_some() {
5066 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5067 }
5068 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5069;
5070 }
5071 GeneratedField::TruncateTables => {
5072 if delta_type__.is_some() {
5073 return Err(serde::de::Error::duplicate_field("truncateTables"));
5074 }
5075 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::TruncateTables)
5076;
5077 }
5078 }
5079 }
5080 Ok(GroupDelta {
5081 delta_type: delta_type__,
5082 })
5083 }
5084 }
5085 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5086 }
5087}
5088impl serde::Serialize for GroupDestroy {
5089 #[allow(deprecated)]
5090 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5091 where
5092 S: serde::Serializer,
5093 {
5094 use serde::ser::SerializeStruct;
5095 let len = 0;
5096 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5097 struct_ser.end()
5098 }
5099}
5100impl<'de> serde::Deserialize<'de> for GroupDestroy {
5101 #[allow(deprecated)]
5102 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5103 where
5104 D: serde::Deserializer<'de>,
5105 {
5106 const FIELDS: &[&str] = &[
5107 ];
5108
5109 #[allow(clippy::enum_variant_names)]
5110 enum GeneratedField {
5111 }
5112 impl<'de> serde::Deserialize<'de> for GeneratedField {
5113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5114 where
5115 D: serde::Deserializer<'de>,
5116 {
5117 struct GeneratedVisitor;
5118
5119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5120 type Value = GeneratedField;
5121
5122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5123 write!(formatter, "expected one of: {:?}", &FIELDS)
5124 }
5125
5126 #[allow(unused_variables)]
5127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5128 where
5129 E: serde::de::Error,
5130 {
5131 Err(serde::de::Error::unknown_field(value, FIELDS))
5132 }
5133 }
5134 deserializer.deserialize_identifier(GeneratedVisitor)
5135 }
5136 }
5137 struct GeneratedVisitor;
5138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5139 type Value = GroupDestroy;
5140
5141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5142 formatter.write_str("struct hummock.GroupDestroy")
5143 }
5144
5145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5146 where
5147 V: serde::de::MapAccess<'de>,
5148 {
5149 while map_.next_key::<GeneratedField>()?.is_some() {
5150 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5151 }
5152 Ok(GroupDestroy {
5153 })
5154 }
5155 }
5156 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5157 }
5158}
5159impl serde::Serialize for GroupMerge {
5160 #[allow(deprecated)]
5161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5162 where
5163 S: serde::Serializer,
5164 {
5165 use serde::ser::SerializeStruct;
5166 let mut len = 0;
5167 if self.left_group_id != 0 {
5168 len += 1;
5169 }
5170 if self.right_group_id != 0 {
5171 len += 1;
5172 }
5173 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5174 if self.left_group_id != 0 {
5175 #[allow(clippy::needless_borrow)]
5176 #[allow(clippy::needless_borrows_for_generic_args)]
5177 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5178 }
5179 if self.right_group_id != 0 {
5180 #[allow(clippy::needless_borrow)]
5181 #[allow(clippy::needless_borrows_for_generic_args)]
5182 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5183 }
5184 struct_ser.end()
5185 }
5186}
5187impl<'de> serde::Deserialize<'de> for GroupMerge {
5188 #[allow(deprecated)]
5189 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5190 where
5191 D: serde::Deserializer<'de>,
5192 {
5193 const FIELDS: &[&str] = &[
5194 "left_group_id",
5195 "leftGroupId",
5196 "right_group_id",
5197 "rightGroupId",
5198 ];
5199
5200 #[allow(clippy::enum_variant_names)]
5201 enum GeneratedField {
5202 LeftGroupId,
5203 RightGroupId,
5204 }
5205 impl<'de> serde::Deserialize<'de> for GeneratedField {
5206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5207 where
5208 D: serde::Deserializer<'de>,
5209 {
5210 struct GeneratedVisitor;
5211
5212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5213 type Value = GeneratedField;
5214
5215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5216 write!(formatter, "expected one of: {:?}", &FIELDS)
5217 }
5218
5219 #[allow(unused_variables)]
5220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5221 where
5222 E: serde::de::Error,
5223 {
5224 match value {
5225 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5226 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5227 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5228 }
5229 }
5230 }
5231 deserializer.deserialize_identifier(GeneratedVisitor)
5232 }
5233 }
5234 struct GeneratedVisitor;
5235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5236 type Value = GroupMerge;
5237
5238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5239 formatter.write_str("struct hummock.GroupMerge")
5240 }
5241
5242 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5243 where
5244 V: serde::de::MapAccess<'de>,
5245 {
5246 let mut left_group_id__ = None;
5247 let mut right_group_id__ = None;
5248 while let Some(k) = map_.next_key()? {
5249 match k {
5250 GeneratedField::LeftGroupId => {
5251 if left_group_id__.is_some() {
5252 return Err(serde::de::Error::duplicate_field("leftGroupId"));
5253 }
5254 left_group_id__ =
5255 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5256 ;
5257 }
5258 GeneratedField::RightGroupId => {
5259 if right_group_id__.is_some() {
5260 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5261 }
5262 right_group_id__ =
5263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5264 ;
5265 }
5266 }
5267 }
5268 Ok(GroupMerge {
5269 left_group_id: left_group_id__.unwrap_or_default(),
5270 right_group_id: right_group_id__.unwrap_or_default(),
5271 })
5272 }
5273 }
5274 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5275 }
5276}
5277impl serde::Serialize for HummockPinnedSnapshot {
5278 #[allow(deprecated)]
5279 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5280 where
5281 S: serde::Serializer,
5282 {
5283 use serde::ser::SerializeStruct;
5284 let mut len = 0;
5285 if self.context_id != 0 {
5286 len += 1;
5287 }
5288 if self.minimal_pinned_snapshot != 0 {
5289 len += 1;
5290 }
5291 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
5292 if self.context_id != 0 {
5293 struct_ser.serialize_field("contextId", &self.context_id)?;
5294 }
5295 if self.minimal_pinned_snapshot != 0 {
5296 #[allow(clippy::needless_borrow)]
5297 #[allow(clippy::needless_borrows_for_generic_args)]
5298 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
5299 }
5300 struct_ser.end()
5301 }
5302}
5303impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
5304 #[allow(deprecated)]
5305 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5306 where
5307 D: serde::Deserializer<'de>,
5308 {
5309 const FIELDS: &[&str] = &[
5310 "context_id",
5311 "contextId",
5312 "minimal_pinned_snapshot",
5313 "minimalPinnedSnapshot",
5314 ];
5315
5316 #[allow(clippy::enum_variant_names)]
5317 enum GeneratedField {
5318 ContextId,
5319 MinimalPinnedSnapshot,
5320 }
5321 impl<'de> serde::Deserialize<'de> for GeneratedField {
5322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5323 where
5324 D: serde::Deserializer<'de>,
5325 {
5326 struct GeneratedVisitor;
5327
5328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5329 type Value = GeneratedField;
5330
5331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5332 write!(formatter, "expected one of: {:?}", &FIELDS)
5333 }
5334
5335 #[allow(unused_variables)]
5336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5337 where
5338 E: serde::de::Error,
5339 {
5340 match value {
5341 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5342 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
5343 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5344 }
5345 }
5346 }
5347 deserializer.deserialize_identifier(GeneratedVisitor)
5348 }
5349 }
5350 struct GeneratedVisitor;
5351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5352 type Value = HummockPinnedSnapshot;
5353
5354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5355 formatter.write_str("struct hummock.HummockPinnedSnapshot")
5356 }
5357
5358 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
5359 where
5360 V: serde::de::MapAccess<'de>,
5361 {
5362 let mut context_id__ = None;
5363 let mut minimal_pinned_snapshot__ = None;
5364 while let Some(k) = map_.next_key()? {
5365 match k {
5366 GeneratedField::ContextId => {
5367 if context_id__.is_some() {
5368 return Err(serde::de::Error::duplicate_field("contextId"));
5369 }
5370 context_id__ =
5371 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5372 ;
5373 }
5374 GeneratedField::MinimalPinnedSnapshot => {
5375 if minimal_pinned_snapshot__.is_some() {
5376 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
5377 }
5378 minimal_pinned_snapshot__ =
5379 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5380 ;
5381 }
5382 }
5383 }
5384 Ok(HummockPinnedSnapshot {
5385 context_id: context_id__.unwrap_or_default(),
5386 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
5387 })
5388 }
5389 }
5390 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
5391 }
5392}
5393impl serde::Serialize for HummockPinnedVersion {
5394 #[allow(deprecated)]
5395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5396 where
5397 S: serde::Serializer,
5398 {
5399 use serde::ser::SerializeStruct;
5400 let mut len = 0;
5401 if self.context_id != 0 {
5402 len += 1;
5403 }
5404 if self.min_pinned_id != 0 {
5405 len += 1;
5406 }
5407 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
5408 if self.context_id != 0 {
5409 struct_ser.serialize_field("contextId", &self.context_id)?;
5410 }
5411 if self.min_pinned_id != 0 {
5412 #[allow(clippy::needless_borrow)]
5413 #[allow(clippy::needless_borrows_for_generic_args)]
5414 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
5415 }
5416 struct_ser.end()
5417 }
5418}
5419impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
5420 #[allow(deprecated)]
5421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5422 where
5423 D: serde::Deserializer<'de>,
5424 {
5425 const FIELDS: &[&str] = &[
5426 "context_id",
5427 "contextId",
5428 "min_pinned_id",
5429 "minPinnedId",
5430 ];
5431
5432 #[allow(clippy::enum_variant_names)]
5433 enum GeneratedField {
5434 ContextId,
5435 MinPinnedId,
5436 }
5437 impl<'de> serde::Deserialize<'de> for GeneratedField {
5438 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5439 where
5440 D: serde::Deserializer<'de>,
5441 {
5442 struct GeneratedVisitor;
5443
5444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5445 type Value = GeneratedField;
5446
5447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5448 write!(formatter, "expected one of: {:?}", &FIELDS)
5449 }
5450
5451 #[allow(unused_variables)]
5452 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5453 where
5454 E: serde::de::Error,
5455 {
5456 match value {
5457 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5458 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
5459 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5460 }
5461 }
5462 }
5463 deserializer.deserialize_identifier(GeneratedVisitor)
5464 }
5465 }
5466 struct GeneratedVisitor;
5467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5468 type Value = HummockPinnedVersion;
5469
5470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5471 formatter.write_str("struct hummock.HummockPinnedVersion")
5472 }
5473
5474 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
5475 where
5476 V: serde::de::MapAccess<'de>,
5477 {
5478 let mut context_id__ = None;
5479 let mut min_pinned_id__ = None;
5480 while let Some(k) = map_.next_key()? {
5481 match k {
5482 GeneratedField::ContextId => {
5483 if context_id__.is_some() {
5484 return Err(serde::de::Error::duplicate_field("contextId"));
5485 }
5486 context_id__ =
5487 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5488 ;
5489 }
5490 GeneratedField::MinPinnedId => {
5491 if min_pinned_id__.is_some() {
5492 return Err(serde::de::Error::duplicate_field("minPinnedId"));
5493 }
5494 min_pinned_id__ =
5495 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5496 ;
5497 }
5498 }
5499 }
5500 Ok(HummockPinnedVersion {
5501 context_id: context_id__.unwrap_or_default(),
5502 min_pinned_id: min_pinned_id__.unwrap_or_default(),
5503 })
5504 }
5505 }
5506 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
5507 }
5508}
5509impl serde::Serialize for HummockVersion {
5510 #[allow(deprecated)]
5511 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5512 where
5513 S: serde::Serializer,
5514 {
5515 use serde::ser::SerializeStruct;
5516 let mut len = 0;
5517 if self.id != 0 {
5518 len += 1;
5519 }
5520 if !self.levels.is_empty() {
5521 len += 1;
5522 }
5523 if self.max_committed_epoch != 0 {
5524 len += 1;
5525 }
5526 if !self.table_watermarks.is_empty() {
5527 len += 1;
5528 }
5529 if !self.table_change_logs.is_empty() {
5530 len += 1;
5531 }
5532 if !self.state_table_info.is_empty() {
5533 len += 1;
5534 }
5535 if !self.vector_indexes.is_empty() {
5536 len += 1;
5537 }
5538 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
5539 if self.id != 0 {
5540 #[allow(clippy::needless_borrow)]
5541 #[allow(clippy::needless_borrows_for_generic_args)]
5542 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
5543 }
5544 if !self.levels.is_empty() {
5545 struct_ser.serialize_field("levels", &self.levels)?;
5546 }
5547 if self.max_committed_epoch != 0 {
5548 #[allow(clippy::needless_borrow)]
5549 #[allow(clippy::needless_borrows_for_generic_args)]
5550 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
5551 }
5552 if !self.table_watermarks.is_empty() {
5553 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
5554 }
5555 if !self.table_change_logs.is_empty() {
5556 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
5557 }
5558 if !self.state_table_info.is_empty() {
5559 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
5560 }
5561 if !self.vector_indexes.is_empty() {
5562 struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
5563 }
5564 struct_ser.end()
5565 }
5566}
5567impl<'de> serde::Deserialize<'de> for HummockVersion {
5568 #[allow(deprecated)]
5569 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5570 where
5571 D: serde::Deserializer<'de>,
5572 {
5573 const FIELDS: &[&str] = &[
5574 "id",
5575 "levels",
5576 "max_committed_epoch",
5577 "maxCommittedEpoch",
5578 "table_watermarks",
5579 "tableWatermarks",
5580 "table_change_logs",
5581 "tableChangeLogs",
5582 "state_table_info",
5583 "stateTableInfo",
5584 "vector_indexes",
5585 "vectorIndexes",
5586 ];
5587
5588 #[allow(clippy::enum_variant_names)]
5589 enum GeneratedField {
5590 Id,
5591 Levels,
5592 MaxCommittedEpoch,
5593 TableWatermarks,
5594 TableChangeLogs,
5595 StateTableInfo,
5596 VectorIndexes,
5597 }
5598 impl<'de> serde::Deserialize<'de> for GeneratedField {
5599 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5600 where
5601 D: serde::Deserializer<'de>,
5602 {
5603 struct GeneratedVisitor;
5604
5605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5606 type Value = GeneratedField;
5607
5608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5609 write!(formatter, "expected one of: {:?}", &FIELDS)
5610 }
5611
5612 #[allow(unused_variables)]
5613 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5614 where
5615 E: serde::de::Error,
5616 {
5617 match value {
5618 "id" => Ok(GeneratedField::Id),
5619 "levels" => Ok(GeneratedField::Levels),
5620 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
5621 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
5622 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
5623 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
5624 "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
5625 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5626 }
5627 }
5628 }
5629 deserializer.deserialize_identifier(GeneratedVisitor)
5630 }
5631 }
5632 struct GeneratedVisitor;
5633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5634 type Value = HummockVersion;
5635
5636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5637 formatter.write_str("struct hummock.HummockVersion")
5638 }
5639
5640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
5641 where
5642 V: serde::de::MapAccess<'de>,
5643 {
5644 let mut id__ = None;
5645 let mut levels__ = None;
5646 let mut max_committed_epoch__ = None;
5647 let mut table_watermarks__ = None;
5648 let mut table_change_logs__ = None;
5649 let mut state_table_info__ = None;
5650 let mut vector_indexes__ = None;
5651 while let Some(k) = map_.next_key()? {
5652 match k {
5653 GeneratedField::Id => {
5654 if id__.is_some() {
5655 return Err(serde::de::Error::duplicate_field("id"));
5656 }
5657 id__ =
5658 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5659 ;
5660 }
5661 GeneratedField::Levels => {
5662 if levels__.is_some() {
5663 return Err(serde::de::Error::duplicate_field("levels"));
5664 }
5665 levels__ = Some(
5666 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
5667 .into_iter().map(|(k,v)| (k.0, v)).collect()
5668 );
5669 }
5670 GeneratedField::MaxCommittedEpoch => {
5671 if max_committed_epoch__.is_some() {
5672 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
5673 }
5674 max_committed_epoch__ =
5675 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5676 ;
5677 }
5678 GeneratedField::TableWatermarks => {
5679 if table_watermarks__.is_some() {
5680 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
5681 }
5682 table_watermarks__ = Some(
5683 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5684 .into_iter().map(|(k,v)| (k.0, v)).collect()
5685 );
5686 }
5687 GeneratedField::TableChangeLogs => {
5688 if table_change_logs__.is_some() {
5689 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
5690 }
5691 table_change_logs__ = Some(
5692 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5693 .into_iter().map(|(k,v)| (k.0, v)).collect()
5694 );
5695 }
5696 GeneratedField::StateTableInfo => {
5697 if state_table_info__.is_some() {
5698 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
5699 }
5700 state_table_info__ = Some(
5701 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5702 .into_iter().map(|(k,v)| (k.0, v)).collect()
5703 );
5704 }
5705 GeneratedField::VectorIndexes => {
5706 if vector_indexes__.is_some() {
5707 return Err(serde::de::Error::duplicate_field("vectorIndexes"));
5708 }
5709 vector_indexes__ = Some(
5710 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5711 .into_iter().map(|(k,v)| (k.0, v)).collect()
5712 );
5713 }
5714 }
5715 }
5716 Ok(HummockVersion {
5717 id: id__.unwrap_or_default(),
5718 levels: levels__.unwrap_or_default(),
5719 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
5720 table_watermarks: table_watermarks__.unwrap_or_default(),
5721 table_change_logs: table_change_logs__.unwrap_or_default(),
5722 state_table_info: state_table_info__.unwrap_or_default(),
5723 vector_indexes: vector_indexes__.unwrap_or_default(),
5724 })
5725 }
5726 }
5727 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
5728 }
5729}
5730impl serde::Serialize for hummock_version::Levels {
5731 #[allow(deprecated)]
5732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5733 where
5734 S: serde::Serializer,
5735 {
5736 use serde::ser::SerializeStruct;
5737 let mut len = 0;
5738 if !self.levels.is_empty() {
5739 len += 1;
5740 }
5741 if self.l0.is_some() {
5742 len += 1;
5743 }
5744 if self.group_id != 0 {
5745 len += 1;
5746 }
5747 if self.parent_group_id != 0 {
5748 len += 1;
5749 }
5750 if !self.member_table_ids.is_empty() {
5751 len += 1;
5752 }
5753 if self.compaction_group_version_id != 0 {
5754 len += 1;
5755 }
5756 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
5757 if !self.levels.is_empty() {
5758 struct_ser.serialize_field("levels", &self.levels)?;
5759 }
5760 if let Some(v) = self.l0.as_ref() {
5761 struct_ser.serialize_field("l0", v)?;
5762 }
5763 if self.group_id != 0 {
5764 #[allow(clippy::needless_borrow)]
5765 #[allow(clippy::needless_borrows_for_generic_args)]
5766 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
5767 }
5768 if self.parent_group_id != 0 {
5769 #[allow(clippy::needless_borrow)]
5770 #[allow(clippy::needless_borrows_for_generic_args)]
5771 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
5772 }
5773 if !self.member_table_ids.is_empty() {
5774 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
5775 }
5776 if self.compaction_group_version_id != 0 {
5777 #[allow(clippy::needless_borrow)]
5778 #[allow(clippy::needless_borrows_for_generic_args)]
5779 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
5780 }
5781 struct_ser.end()
5782 }
5783}
5784impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
5785 #[allow(deprecated)]
5786 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5787 where
5788 D: serde::Deserializer<'de>,
5789 {
5790 const FIELDS: &[&str] = &[
5791 "levels",
5792 "l0",
5793 "group_id",
5794 "groupId",
5795 "parent_group_id",
5796 "parentGroupId",
5797 "member_table_ids",
5798 "memberTableIds",
5799 "compaction_group_version_id",
5800 "compactionGroupVersionId",
5801 ];
5802
5803 #[allow(clippy::enum_variant_names)]
5804 enum GeneratedField {
5805 Levels,
5806 L0,
5807 GroupId,
5808 ParentGroupId,
5809 MemberTableIds,
5810 CompactionGroupVersionId,
5811 }
5812 impl<'de> serde::Deserialize<'de> for GeneratedField {
5813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5814 where
5815 D: serde::Deserializer<'de>,
5816 {
5817 struct GeneratedVisitor;
5818
5819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5820 type Value = GeneratedField;
5821
5822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5823 write!(formatter, "expected one of: {:?}", &FIELDS)
5824 }
5825
5826 #[allow(unused_variables)]
5827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5828 where
5829 E: serde::de::Error,
5830 {
5831 match value {
5832 "levels" => Ok(GeneratedField::Levels),
5833 "l0" => Ok(GeneratedField::L0),
5834 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
5835 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
5836 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
5837 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
5838 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5839 }
5840 }
5841 }
5842 deserializer.deserialize_identifier(GeneratedVisitor)
5843 }
5844 }
5845 struct GeneratedVisitor;
5846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5847 type Value = hummock_version::Levels;
5848
5849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5850 formatter.write_str("struct hummock.HummockVersion.Levels")
5851 }
5852
5853 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
5854 where
5855 V: serde::de::MapAccess<'de>,
5856 {
5857 let mut levels__ = None;
5858 let mut l0__ = None;
5859 let mut group_id__ = None;
5860 let mut parent_group_id__ = None;
5861 let mut member_table_ids__ = None;
5862 let mut compaction_group_version_id__ = None;
5863 while let Some(k) = map_.next_key()? {
5864 match k {
5865 GeneratedField::Levels => {
5866 if levels__.is_some() {
5867 return Err(serde::de::Error::duplicate_field("levels"));
5868 }
5869 levels__ = Some(map_.next_value()?);
5870 }
5871 GeneratedField::L0 => {
5872 if l0__.is_some() {
5873 return Err(serde::de::Error::duplicate_field("l0"));
5874 }
5875 l0__ = map_.next_value()?;
5876 }
5877 GeneratedField::GroupId => {
5878 if group_id__.is_some() {
5879 return Err(serde::de::Error::duplicate_field("groupId"));
5880 }
5881 group_id__ =
5882 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5883 ;
5884 }
5885 GeneratedField::ParentGroupId => {
5886 if parent_group_id__.is_some() {
5887 return Err(serde::de::Error::duplicate_field("parentGroupId"));
5888 }
5889 parent_group_id__ =
5890 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5891 ;
5892 }
5893 GeneratedField::MemberTableIds => {
5894 if member_table_ids__.is_some() {
5895 return Err(serde::de::Error::duplicate_field("memberTableIds"));
5896 }
5897 member_table_ids__ =
5898 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5899 .into_iter().map(|x| x.0).collect())
5900 ;
5901 }
5902 GeneratedField::CompactionGroupVersionId => {
5903 if compaction_group_version_id__.is_some() {
5904 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
5905 }
5906 compaction_group_version_id__ =
5907 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5908 ;
5909 }
5910 }
5911 }
5912 Ok(hummock_version::Levels {
5913 levels: levels__.unwrap_or_default(),
5914 l0: l0__,
5915 group_id: group_id__.unwrap_or_default(),
5916 parent_group_id: parent_group_id__.unwrap_or_default(),
5917 member_table_ids: member_table_ids__.unwrap_or_default(),
5918 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
5919 })
5920 }
5921 }
5922 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
5923 }
5924}
5925impl serde::Serialize for HummockVersionArchive {
5926 #[allow(deprecated)]
5927 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5928 where
5929 S: serde::Serializer,
5930 {
5931 use serde::ser::SerializeStruct;
5932 let mut len = 0;
5933 if self.version.is_some() {
5934 len += 1;
5935 }
5936 if !self.version_deltas.is_empty() {
5937 len += 1;
5938 }
5939 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
5940 if let Some(v) = self.version.as_ref() {
5941 struct_ser.serialize_field("version", v)?;
5942 }
5943 if !self.version_deltas.is_empty() {
5944 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
5945 }
5946 struct_ser.end()
5947 }
5948}
5949impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
5950 #[allow(deprecated)]
5951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5952 where
5953 D: serde::Deserializer<'de>,
5954 {
5955 const FIELDS: &[&str] = &[
5956 "version",
5957 "version_deltas",
5958 "versionDeltas",
5959 ];
5960
5961 #[allow(clippy::enum_variant_names)]
5962 enum GeneratedField {
5963 Version,
5964 VersionDeltas,
5965 }
5966 impl<'de> serde::Deserialize<'de> for GeneratedField {
5967 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5968 where
5969 D: serde::Deserializer<'de>,
5970 {
5971 struct GeneratedVisitor;
5972
5973 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5974 type Value = GeneratedField;
5975
5976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5977 write!(formatter, "expected one of: {:?}", &FIELDS)
5978 }
5979
5980 #[allow(unused_variables)]
5981 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5982 where
5983 E: serde::de::Error,
5984 {
5985 match value {
5986 "version" => Ok(GeneratedField::Version),
5987 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
5988 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5989 }
5990 }
5991 }
5992 deserializer.deserialize_identifier(GeneratedVisitor)
5993 }
5994 }
5995 struct GeneratedVisitor;
5996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5997 type Value = HummockVersionArchive;
5998
5999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6000 formatter.write_str("struct hummock.HummockVersionArchive")
6001 }
6002
6003 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
6004 where
6005 V: serde::de::MapAccess<'de>,
6006 {
6007 let mut version__ = None;
6008 let mut version_deltas__ = None;
6009 while let Some(k) = map_.next_key()? {
6010 match k {
6011 GeneratedField::Version => {
6012 if version__.is_some() {
6013 return Err(serde::de::Error::duplicate_field("version"));
6014 }
6015 version__ = map_.next_value()?;
6016 }
6017 GeneratedField::VersionDeltas => {
6018 if version_deltas__.is_some() {
6019 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6020 }
6021 version_deltas__ = Some(map_.next_value()?);
6022 }
6023 }
6024 }
6025 Ok(HummockVersionArchive {
6026 version: version__,
6027 version_deltas: version_deltas__.unwrap_or_default(),
6028 })
6029 }
6030 }
6031 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
6032 }
6033}
6034impl serde::Serialize for HummockVersionCheckpoint {
6035 #[allow(deprecated)]
6036 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6037 where
6038 S: serde::Serializer,
6039 {
6040 use serde::ser::SerializeStruct;
6041 let mut len = 0;
6042 if self.version.is_some() {
6043 len += 1;
6044 }
6045 if !self.stale_objects.is_empty() {
6046 len += 1;
6047 }
6048 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
6049 if let Some(v) = self.version.as_ref() {
6050 struct_ser.serialize_field("version", v)?;
6051 }
6052 if !self.stale_objects.is_empty() {
6053 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
6054 }
6055 struct_ser.end()
6056 }
6057}
6058impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
6059 #[allow(deprecated)]
6060 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6061 where
6062 D: serde::Deserializer<'de>,
6063 {
6064 const FIELDS: &[&str] = &[
6065 "version",
6066 "stale_objects",
6067 "staleObjects",
6068 ];
6069
6070 #[allow(clippy::enum_variant_names)]
6071 enum GeneratedField {
6072 Version,
6073 StaleObjects,
6074 }
6075 impl<'de> serde::Deserialize<'de> for GeneratedField {
6076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6077 where
6078 D: serde::Deserializer<'de>,
6079 {
6080 struct GeneratedVisitor;
6081
6082 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6083 type Value = GeneratedField;
6084
6085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6086 write!(formatter, "expected one of: {:?}", &FIELDS)
6087 }
6088
6089 #[allow(unused_variables)]
6090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6091 where
6092 E: serde::de::Error,
6093 {
6094 match value {
6095 "version" => Ok(GeneratedField::Version),
6096 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
6097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6098 }
6099 }
6100 }
6101 deserializer.deserialize_identifier(GeneratedVisitor)
6102 }
6103 }
6104 struct GeneratedVisitor;
6105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6106 type Value = HummockVersionCheckpoint;
6107
6108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6109 formatter.write_str("struct hummock.HummockVersionCheckpoint")
6110 }
6111
6112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
6113 where
6114 V: serde::de::MapAccess<'de>,
6115 {
6116 let mut version__ = None;
6117 let mut stale_objects__ = None;
6118 while let Some(k) = map_.next_key()? {
6119 match k {
6120 GeneratedField::Version => {
6121 if version__.is_some() {
6122 return Err(serde::de::Error::duplicate_field("version"));
6123 }
6124 version__ = map_.next_value()?;
6125 }
6126 GeneratedField::StaleObjects => {
6127 if stale_objects__.is_some() {
6128 return Err(serde::de::Error::duplicate_field("staleObjects"));
6129 }
6130 stale_objects__ = Some(
6131 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6132 .into_iter().map(|(k,v)| (k.0, v)).collect()
6133 );
6134 }
6135 }
6136 }
6137 Ok(HummockVersionCheckpoint {
6138 version: version__,
6139 stale_objects: stale_objects__.unwrap_or_default(),
6140 })
6141 }
6142 }
6143 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
6144 }
6145}
6146impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
6147 #[allow(deprecated)]
6148 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6149 where
6150 S: serde::Serializer,
6151 {
6152 use serde::ser::SerializeStruct;
6153 let mut len = 0;
6154 if !self.id.is_empty() {
6155 len += 1;
6156 }
6157 if self.total_file_size != 0 {
6158 len += 1;
6159 }
6160 if !self.vector_files.is_empty() {
6161 len += 1;
6162 }
6163 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
6164 if !self.id.is_empty() {
6165 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
6166 }
6167 if self.total_file_size != 0 {
6168 #[allow(clippy::needless_borrow)]
6169 #[allow(clippy::needless_borrows_for_generic_args)]
6170 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
6171 }
6172 if !self.vector_files.is_empty() {
6173 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
6174 }
6175 struct_ser.end()
6176 }
6177}
6178impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
6179 #[allow(deprecated)]
6180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6181 where
6182 D: serde::Deserializer<'de>,
6183 {
6184 const FIELDS: &[&str] = &[
6185 "id",
6186 "total_file_size",
6187 "totalFileSize",
6188 "vector_files",
6189 "vectorFiles",
6190 ];
6191
6192 #[allow(clippy::enum_variant_names)]
6193 enum GeneratedField {
6194 Id,
6195 TotalFileSize,
6196 VectorFiles,
6197 }
6198 impl<'de> serde::Deserialize<'de> for GeneratedField {
6199 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6200 where
6201 D: serde::Deserializer<'de>,
6202 {
6203 struct GeneratedVisitor;
6204
6205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6206 type Value = GeneratedField;
6207
6208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6209 write!(formatter, "expected one of: {:?}", &FIELDS)
6210 }
6211
6212 #[allow(unused_variables)]
6213 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6214 where
6215 E: serde::de::Error,
6216 {
6217 match value {
6218 "id" => Ok(GeneratedField::Id),
6219 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
6220 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
6221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6222 }
6223 }
6224 }
6225 deserializer.deserialize_identifier(GeneratedVisitor)
6226 }
6227 }
6228 struct GeneratedVisitor;
6229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6230 type Value = hummock_version_checkpoint::StaleObjects;
6231
6232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6233 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
6234 }
6235
6236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
6237 where
6238 V: serde::de::MapAccess<'de>,
6239 {
6240 let mut id__ = None;
6241 let mut total_file_size__ = None;
6242 let mut vector_files__ = None;
6243 while let Some(k) = map_.next_key()? {
6244 match k {
6245 GeneratedField::Id => {
6246 if id__.is_some() {
6247 return Err(serde::de::Error::duplicate_field("id"));
6248 }
6249 id__ =
6250 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6251 .into_iter().map(|x| x.0).collect())
6252 ;
6253 }
6254 GeneratedField::TotalFileSize => {
6255 if total_file_size__.is_some() {
6256 return Err(serde::de::Error::duplicate_field("totalFileSize"));
6257 }
6258 total_file_size__ =
6259 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6260 ;
6261 }
6262 GeneratedField::VectorFiles => {
6263 if vector_files__.is_some() {
6264 return Err(serde::de::Error::duplicate_field("vectorFiles"));
6265 }
6266 vector_files__ = Some(map_.next_value()?);
6267 }
6268 }
6269 }
6270 Ok(hummock_version_checkpoint::StaleObjects {
6271 id: id__.unwrap_or_default(),
6272 total_file_size: total_file_size__.unwrap_or_default(),
6273 vector_files: vector_files__.unwrap_or_default(),
6274 })
6275 }
6276 }
6277 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
6278 }
6279}
6280impl serde::Serialize for HummockVersionDelta {
6281 #[allow(deprecated)]
6282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6283 where
6284 S: serde::Serializer,
6285 {
6286 use serde::ser::SerializeStruct;
6287 let mut len = 0;
6288 if self.id != 0 {
6289 len += 1;
6290 }
6291 if self.prev_id != 0 {
6292 len += 1;
6293 }
6294 if !self.group_deltas.is_empty() {
6295 len += 1;
6296 }
6297 if self.max_committed_epoch != 0 {
6298 len += 1;
6299 }
6300 if self.trivial_move {
6301 len += 1;
6302 }
6303 if !self.new_table_watermarks.is_empty() {
6304 len += 1;
6305 }
6306 if !self.removed_table_ids.is_empty() {
6307 len += 1;
6308 }
6309 if !self.change_log_delta.is_empty() {
6310 len += 1;
6311 }
6312 if !self.state_table_info_delta.is_empty() {
6313 len += 1;
6314 }
6315 if !self.vector_index_delta.is_empty() {
6316 len += 1;
6317 }
6318 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
6319 if self.id != 0 {
6320 #[allow(clippy::needless_borrow)]
6321 #[allow(clippy::needless_borrows_for_generic_args)]
6322 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6323 }
6324 if self.prev_id != 0 {
6325 #[allow(clippy::needless_borrow)]
6326 #[allow(clippy::needless_borrows_for_generic_args)]
6327 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
6328 }
6329 if !self.group_deltas.is_empty() {
6330 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6331 }
6332 if self.max_committed_epoch != 0 {
6333 #[allow(clippy::needless_borrow)]
6334 #[allow(clippy::needless_borrows_for_generic_args)]
6335 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6336 }
6337 if self.trivial_move {
6338 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
6339 }
6340 if !self.new_table_watermarks.is_empty() {
6341 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
6342 }
6343 if !self.removed_table_ids.is_empty() {
6344 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
6345 }
6346 if !self.change_log_delta.is_empty() {
6347 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
6348 }
6349 if !self.state_table_info_delta.is_empty() {
6350 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
6351 }
6352 if !self.vector_index_delta.is_empty() {
6353 struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
6354 }
6355 struct_ser.end()
6356 }
6357}
6358impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
6359 #[allow(deprecated)]
6360 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6361 where
6362 D: serde::Deserializer<'de>,
6363 {
6364 const FIELDS: &[&str] = &[
6365 "id",
6366 "prev_id",
6367 "prevId",
6368 "group_deltas",
6369 "groupDeltas",
6370 "max_committed_epoch",
6371 "maxCommittedEpoch",
6372 "trivial_move",
6373 "trivialMove",
6374 "new_table_watermarks",
6375 "newTableWatermarks",
6376 "removed_table_ids",
6377 "removedTableIds",
6378 "change_log_delta",
6379 "changeLogDelta",
6380 "state_table_info_delta",
6381 "stateTableInfoDelta",
6382 "vector_index_delta",
6383 "vectorIndexDelta",
6384 ];
6385
6386 #[allow(clippy::enum_variant_names)]
6387 enum GeneratedField {
6388 Id,
6389 PrevId,
6390 GroupDeltas,
6391 MaxCommittedEpoch,
6392 TrivialMove,
6393 NewTableWatermarks,
6394 RemovedTableIds,
6395 ChangeLogDelta,
6396 StateTableInfoDelta,
6397 VectorIndexDelta,
6398 }
6399 impl<'de> serde::Deserialize<'de> for GeneratedField {
6400 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6401 where
6402 D: serde::Deserializer<'de>,
6403 {
6404 struct GeneratedVisitor;
6405
6406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6407 type Value = GeneratedField;
6408
6409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6410 write!(formatter, "expected one of: {:?}", &FIELDS)
6411 }
6412
6413 #[allow(unused_variables)]
6414 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6415 where
6416 E: serde::de::Error,
6417 {
6418 match value {
6419 "id" => Ok(GeneratedField::Id),
6420 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
6421 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6422 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6423 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
6424 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
6425 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
6426 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
6427 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
6428 "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
6429 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6430 }
6431 }
6432 }
6433 deserializer.deserialize_identifier(GeneratedVisitor)
6434 }
6435 }
6436 struct GeneratedVisitor;
6437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6438 type Value = HummockVersionDelta;
6439
6440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6441 formatter.write_str("struct hummock.HummockVersionDelta")
6442 }
6443
6444 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
6445 where
6446 V: serde::de::MapAccess<'de>,
6447 {
6448 let mut id__ = None;
6449 let mut prev_id__ = None;
6450 let mut group_deltas__ = None;
6451 let mut max_committed_epoch__ = None;
6452 let mut trivial_move__ = None;
6453 let mut new_table_watermarks__ = None;
6454 let mut removed_table_ids__ = None;
6455 let mut change_log_delta__ = None;
6456 let mut state_table_info_delta__ = None;
6457 let mut vector_index_delta__ = None;
6458 while let Some(k) = map_.next_key()? {
6459 match k {
6460 GeneratedField::Id => {
6461 if id__.is_some() {
6462 return Err(serde::de::Error::duplicate_field("id"));
6463 }
6464 id__ =
6465 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6466 ;
6467 }
6468 GeneratedField::PrevId => {
6469 if prev_id__.is_some() {
6470 return Err(serde::de::Error::duplicate_field("prevId"));
6471 }
6472 prev_id__ =
6473 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6474 ;
6475 }
6476 GeneratedField::GroupDeltas => {
6477 if group_deltas__.is_some() {
6478 return Err(serde::de::Error::duplicate_field("groupDeltas"));
6479 }
6480 group_deltas__ = Some(
6481 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6482 .into_iter().map(|(k,v)| (k.0, v)).collect()
6483 );
6484 }
6485 GeneratedField::MaxCommittedEpoch => {
6486 if max_committed_epoch__.is_some() {
6487 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
6488 }
6489 max_committed_epoch__ =
6490 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6491 ;
6492 }
6493 GeneratedField::TrivialMove => {
6494 if trivial_move__.is_some() {
6495 return Err(serde::de::Error::duplicate_field("trivialMove"));
6496 }
6497 trivial_move__ = Some(map_.next_value()?);
6498 }
6499 GeneratedField::NewTableWatermarks => {
6500 if new_table_watermarks__.is_some() {
6501 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
6502 }
6503 new_table_watermarks__ = Some(
6504 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6505 .into_iter().map(|(k,v)| (k.0, v)).collect()
6506 );
6507 }
6508 GeneratedField::RemovedTableIds => {
6509 if removed_table_ids__.is_some() {
6510 return Err(serde::de::Error::duplicate_field("removedTableIds"));
6511 }
6512 removed_table_ids__ =
6513 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6514 .into_iter().map(|x| x.0).collect())
6515 ;
6516 }
6517 GeneratedField::ChangeLogDelta => {
6518 if change_log_delta__.is_some() {
6519 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
6520 }
6521 change_log_delta__ = Some(
6522 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6523 .into_iter().map(|(k,v)| (k.0, v)).collect()
6524 );
6525 }
6526 GeneratedField::StateTableInfoDelta => {
6527 if state_table_info_delta__.is_some() {
6528 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
6529 }
6530 state_table_info_delta__ = Some(
6531 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6532 .into_iter().map(|(k,v)| (k.0, v)).collect()
6533 );
6534 }
6535 GeneratedField::VectorIndexDelta => {
6536 if vector_index_delta__.is_some() {
6537 return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
6538 }
6539 vector_index_delta__ = Some(
6540 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6541 .into_iter().map(|(k,v)| (k.0, v)).collect()
6542 );
6543 }
6544 }
6545 }
6546 Ok(HummockVersionDelta {
6547 id: id__.unwrap_or_default(),
6548 prev_id: prev_id__.unwrap_or_default(),
6549 group_deltas: group_deltas__.unwrap_or_default(),
6550 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
6551 trivial_move: trivial_move__.unwrap_or_default(),
6552 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
6553 removed_table_ids: removed_table_ids__.unwrap_or_default(),
6554 change_log_delta: change_log_delta__.unwrap_or_default(),
6555 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
6556 vector_index_delta: vector_index_delta__.unwrap_or_default(),
6557 })
6558 }
6559 }
6560 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
6561 }
6562}
6563impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
6564 #[allow(deprecated)]
6565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6566 where
6567 S: serde::Serializer,
6568 {
6569 use serde::ser::SerializeStruct;
6570 let mut len = 0;
6571 if self.new_log.is_some() {
6572 len += 1;
6573 }
6574 if self.truncate_epoch != 0 {
6575 len += 1;
6576 }
6577 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
6578 if let Some(v) = self.new_log.as_ref() {
6579 struct_ser.serialize_field("newLog", v)?;
6580 }
6581 if self.truncate_epoch != 0 {
6582 #[allow(clippy::needless_borrow)]
6583 #[allow(clippy::needless_borrows_for_generic_args)]
6584 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
6585 }
6586 struct_ser.end()
6587 }
6588}
6589impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
6590 #[allow(deprecated)]
6591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6592 where
6593 D: serde::Deserializer<'de>,
6594 {
6595 const FIELDS: &[&str] = &[
6596 "new_log",
6597 "newLog",
6598 "truncate_epoch",
6599 "truncateEpoch",
6600 ];
6601
6602 #[allow(clippy::enum_variant_names)]
6603 enum GeneratedField {
6604 NewLog,
6605 TruncateEpoch,
6606 }
6607 impl<'de> serde::Deserialize<'de> for GeneratedField {
6608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6609 where
6610 D: serde::Deserializer<'de>,
6611 {
6612 struct GeneratedVisitor;
6613
6614 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6615 type Value = GeneratedField;
6616
6617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6618 write!(formatter, "expected one of: {:?}", &FIELDS)
6619 }
6620
6621 #[allow(unused_variables)]
6622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6623 where
6624 E: serde::de::Error,
6625 {
6626 match value {
6627 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
6628 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
6629 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6630 }
6631 }
6632 }
6633 deserializer.deserialize_identifier(GeneratedVisitor)
6634 }
6635 }
6636 struct GeneratedVisitor;
6637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6638 type Value = hummock_version_delta::ChangeLogDelta;
6639
6640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6641 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
6642 }
6643
6644 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
6645 where
6646 V: serde::de::MapAccess<'de>,
6647 {
6648 let mut new_log__ = None;
6649 let mut truncate_epoch__ = None;
6650 while let Some(k) = map_.next_key()? {
6651 match k {
6652 GeneratedField::NewLog => {
6653 if new_log__.is_some() {
6654 return Err(serde::de::Error::duplicate_field("newLog"));
6655 }
6656 new_log__ = map_.next_value()?;
6657 }
6658 GeneratedField::TruncateEpoch => {
6659 if truncate_epoch__.is_some() {
6660 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
6661 }
6662 truncate_epoch__ =
6663 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6664 ;
6665 }
6666 }
6667 }
6668 Ok(hummock_version_delta::ChangeLogDelta {
6669 new_log: new_log__,
6670 truncate_epoch: truncate_epoch__.unwrap_or_default(),
6671 })
6672 }
6673 }
6674 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
6675 }
6676}
6677impl serde::Serialize for hummock_version_delta::GroupDeltas {
6678 #[allow(deprecated)]
6679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6680 where
6681 S: serde::Serializer,
6682 {
6683 use serde::ser::SerializeStruct;
6684 let mut len = 0;
6685 if !self.group_deltas.is_empty() {
6686 len += 1;
6687 }
6688 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
6689 if !self.group_deltas.is_empty() {
6690 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6691 }
6692 struct_ser.end()
6693 }
6694}
6695impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
6696 #[allow(deprecated)]
6697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6698 where
6699 D: serde::Deserializer<'de>,
6700 {
6701 const FIELDS: &[&str] = &[
6702 "group_deltas",
6703 "groupDeltas",
6704 ];
6705
6706 #[allow(clippy::enum_variant_names)]
6707 enum GeneratedField {
6708 GroupDeltas,
6709 }
6710 impl<'de> serde::Deserialize<'de> for GeneratedField {
6711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6712 where
6713 D: serde::Deserializer<'de>,
6714 {
6715 struct GeneratedVisitor;
6716
6717 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6718 type Value = GeneratedField;
6719
6720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6721 write!(formatter, "expected one of: {:?}", &FIELDS)
6722 }
6723
6724 #[allow(unused_variables)]
6725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6726 where
6727 E: serde::de::Error,
6728 {
6729 match value {
6730 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6732 }
6733 }
6734 }
6735 deserializer.deserialize_identifier(GeneratedVisitor)
6736 }
6737 }
6738 struct GeneratedVisitor;
6739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6740 type Value = hummock_version_delta::GroupDeltas;
6741
6742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6743 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
6744 }
6745
6746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
6747 where
6748 V: serde::de::MapAccess<'de>,
6749 {
6750 let mut group_deltas__ = None;
6751 while let Some(k) = map_.next_key()? {
6752 match k {
6753 GeneratedField::GroupDeltas => {
6754 if group_deltas__.is_some() {
6755 return Err(serde::de::Error::duplicate_field("groupDeltas"));
6756 }
6757 group_deltas__ = Some(map_.next_value()?);
6758 }
6759 }
6760 }
6761 Ok(hummock_version_delta::GroupDeltas {
6762 group_deltas: group_deltas__.unwrap_or_default(),
6763 })
6764 }
6765 }
6766 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
6767 }
6768}
6769impl serde::Serialize for HummockVersionDeltas {
6770 #[allow(deprecated)]
6771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6772 where
6773 S: serde::Serializer,
6774 {
6775 use serde::ser::SerializeStruct;
6776 let mut len = 0;
6777 if !self.version_deltas.is_empty() {
6778 len += 1;
6779 }
6780 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
6781 if !self.version_deltas.is_empty() {
6782 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6783 }
6784 struct_ser.end()
6785 }
6786}
6787impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
6788 #[allow(deprecated)]
6789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6790 where
6791 D: serde::Deserializer<'de>,
6792 {
6793 const FIELDS: &[&str] = &[
6794 "version_deltas",
6795 "versionDeltas",
6796 ];
6797
6798 #[allow(clippy::enum_variant_names)]
6799 enum GeneratedField {
6800 VersionDeltas,
6801 }
6802 impl<'de> serde::Deserialize<'de> for GeneratedField {
6803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6804 where
6805 D: serde::Deserializer<'de>,
6806 {
6807 struct GeneratedVisitor;
6808
6809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6810 type Value = GeneratedField;
6811
6812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6813 write!(formatter, "expected one of: {:?}", &FIELDS)
6814 }
6815
6816 #[allow(unused_variables)]
6817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6818 where
6819 E: serde::de::Error,
6820 {
6821 match value {
6822 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6823 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6824 }
6825 }
6826 }
6827 deserializer.deserialize_identifier(GeneratedVisitor)
6828 }
6829 }
6830 struct GeneratedVisitor;
6831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6832 type Value = HummockVersionDeltas;
6833
6834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6835 formatter.write_str("struct hummock.HummockVersionDeltas")
6836 }
6837
6838 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
6839 where
6840 V: serde::de::MapAccess<'de>,
6841 {
6842 let mut version_deltas__ = None;
6843 while let Some(k) = map_.next_key()? {
6844 match k {
6845 GeneratedField::VersionDeltas => {
6846 if version_deltas__.is_some() {
6847 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6848 }
6849 version_deltas__ = Some(map_.next_value()?);
6850 }
6851 }
6852 }
6853 Ok(HummockVersionDeltas {
6854 version_deltas: version_deltas__.unwrap_or_default(),
6855 })
6856 }
6857 }
6858 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
6859 }
6860}
6861impl serde::Serialize for HummockVersionStats {
6862 #[allow(deprecated)]
6863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6864 where
6865 S: serde::Serializer,
6866 {
6867 use serde::ser::SerializeStruct;
6868 let mut len = 0;
6869 if self.hummock_version_id != 0 {
6870 len += 1;
6871 }
6872 if !self.table_stats.is_empty() {
6873 len += 1;
6874 }
6875 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
6876 if self.hummock_version_id != 0 {
6877 #[allow(clippy::needless_borrow)]
6878 #[allow(clippy::needless_borrows_for_generic_args)]
6879 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
6880 }
6881 if !self.table_stats.is_empty() {
6882 struct_ser.serialize_field("tableStats", &self.table_stats)?;
6883 }
6884 struct_ser.end()
6885 }
6886}
6887impl<'de> serde::Deserialize<'de> for HummockVersionStats {
6888 #[allow(deprecated)]
6889 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6890 where
6891 D: serde::Deserializer<'de>,
6892 {
6893 const FIELDS: &[&str] = &[
6894 "hummock_version_id",
6895 "hummockVersionId",
6896 "table_stats",
6897 "tableStats",
6898 ];
6899
6900 #[allow(clippy::enum_variant_names)]
6901 enum GeneratedField {
6902 HummockVersionId,
6903 TableStats,
6904 }
6905 impl<'de> serde::Deserialize<'de> for GeneratedField {
6906 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6907 where
6908 D: serde::Deserializer<'de>,
6909 {
6910 struct GeneratedVisitor;
6911
6912 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6913 type Value = GeneratedField;
6914
6915 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6916 write!(formatter, "expected one of: {:?}", &FIELDS)
6917 }
6918
6919 #[allow(unused_variables)]
6920 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6921 where
6922 E: serde::de::Error,
6923 {
6924 match value {
6925 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
6926 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
6927 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6928 }
6929 }
6930 }
6931 deserializer.deserialize_identifier(GeneratedVisitor)
6932 }
6933 }
6934 struct GeneratedVisitor;
6935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6936 type Value = HummockVersionStats;
6937
6938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6939 formatter.write_str("struct hummock.HummockVersionStats")
6940 }
6941
6942 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
6943 where
6944 V: serde::de::MapAccess<'de>,
6945 {
6946 let mut hummock_version_id__ = None;
6947 let mut table_stats__ = None;
6948 while let Some(k) = map_.next_key()? {
6949 match k {
6950 GeneratedField::HummockVersionId => {
6951 if hummock_version_id__.is_some() {
6952 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
6953 }
6954 hummock_version_id__ =
6955 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6956 ;
6957 }
6958 GeneratedField::TableStats => {
6959 if table_stats__.is_some() {
6960 return Err(serde::de::Error::duplicate_field("tableStats"));
6961 }
6962 table_stats__ = Some(
6963 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6964 .into_iter().map(|(k,v)| (k.0, v)).collect()
6965 );
6966 }
6967 }
6968 }
6969 Ok(HummockVersionStats {
6970 hummock_version_id: hummock_version_id__.unwrap_or_default(),
6971 table_stats: table_stats__.unwrap_or_default(),
6972 })
6973 }
6974 }
6975 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
6976 }
6977}
6978impl serde::Serialize for InitMetadataForReplayRequest {
6979 #[allow(deprecated)]
6980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6981 where
6982 S: serde::Serializer,
6983 {
6984 use serde::ser::SerializeStruct;
6985 let mut len = 0;
6986 if !self.tables.is_empty() {
6987 len += 1;
6988 }
6989 if !self.compaction_groups.is_empty() {
6990 len += 1;
6991 }
6992 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
6993 if !self.tables.is_empty() {
6994 struct_ser.serialize_field("tables", &self.tables)?;
6995 }
6996 if !self.compaction_groups.is_empty() {
6997 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
6998 }
6999 struct_ser.end()
7000 }
7001}
7002impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
7003 #[allow(deprecated)]
7004 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7005 where
7006 D: serde::Deserializer<'de>,
7007 {
7008 const FIELDS: &[&str] = &[
7009 "tables",
7010 "compaction_groups",
7011 "compactionGroups",
7012 ];
7013
7014 #[allow(clippy::enum_variant_names)]
7015 enum GeneratedField {
7016 Tables,
7017 CompactionGroups,
7018 }
7019 impl<'de> serde::Deserialize<'de> for GeneratedField {
7020 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7021 where
7022 D: serde::Deserializer<'de>,
7023 {
7024 struct GeneratedVisitor;
7025
7026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7027 type Value = GeneratedField;
7028
7029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7030 write!(formatter, "expected one of: {:?}", &FIELDS)
7031 }
7032
7033 #[allow(unused_variables)]
7034 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7035 where
7036 E: serde::de::Error,
7037 {
7038 match value {
7039 "tables" => Ok(GeneratedField::Tables),
7040 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
7041 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7042 }
7043 }
7044 }
7045 deserializer.deserialize_identifier(GeneratedVisitor)
7046 }
7047 }
7048 struct GeneratedVisitor;
7049 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7050 type Value = InitMetadataForReplayRequest;
7051
7052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7053 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
7054 }
7055
7056 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
7057 where
7058 V: serde::de::MapAccess<'de>,
7059 {
7060 let mut tables__ = None;
7061 let mut compaction_groups__ = None;
7062 while let Some(k) = map_.next_key()? {
7063 match k {
7064 GeneratedField::Tables => {
7065 if tables__.is_some() {
7066 return Err(serde::de::Error::duplicate_field("tables"));
7067 }
7068 tables__ = Some(map_.next_value()?);
7069 }
7070 GeneratedField::CompactionGroups => {
7071 if compaction_groups__.is_some() {
7072 return Err(serde::de::Error::duplicate_field("compactionGroups"));
7073 }
7074 compaction_groups__ = Some(map_.next_value()?);
7075 }
7076 }
7077 }
7078 Ok(InitMetadataForReplayRequest {
7079 tables: tables__.unwrap_or_default(),
7080 compaction_groups: compaction_groups__.unwrap_or_default(),
7081 })
7082 }
7083 }
7084 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
7085 }
7086}
7087impl serde::Serialize for InitMetadataForReplayResponse {
7088 #[allow(deprecated)]
7089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7090 where
7091 S: serde::Serializer,
7092 {
7093 use serde::ser::SerializeStruct;
7094 let len = 0;
7095 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
7096 struct_ser.end()
7097 }
7098}
7099impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
7100 #[allow(deprecated)]
7101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7102 where
7103 D: serde::Deserializer<'de>,
7104 {
7105 const FIELDS: &[&str] = &[
7106 ];
7107
7108 #[allow(clippy::enum_variant_names)]
7109 enum GeneratedField {
7110 }
7111 impl<'de> serde::Deserialize<'de> for GeneratedField {
7112 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7113 where
7114 D: serde::Deserializer<'de>,
7115 {
7116 struct GeneratedVisitor;
7117
7118 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7119 type Value = GeneratedField;
7120
7121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7122 write!(formatter, "expected one of: {:?}", &FIELDS)
7123 }
7124
7125 #[allow(unused_variables)]
7126 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7127 where
7128 E: serde::de::Error,
7129 {
7130 Err(serde::de::Error::unknown_field(value, FIELDS))
7131 }
7132 }
7133 deserializer.deserialize_identifier(GeneratedVisitor)
7134 }
7135 }
7136 struct GeneratedVisitor;
7137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7138 type Value = InitMetadataForReplayResponse;
7139
7140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7141 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
7142 }
7143
7144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
7145 where
7146 V: serde::de::MapAccess<'de>,
7147 {
7148 while map_.next_key::<GeneratedField>()?.is_some() {
7149 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7150 }
7151 Ok(InitMetadataForReplayResponse {
7152 })
7153 }
7154 }
7155 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
7156 }
7157}
7158impl serde::Serialize for InputLevel {
7159 #[allow(deprecated)]
7160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7161 where
7162 S: serde::Serializer,
7163 {
7164 use serde::ser::SerializeStruct;
7165 let mut len = 0;
7166 if self.level_idx != 0 {
7167 len += 1;
7168 }
7169 if self.level_type != 0 {
7170 len += 1;
7171 }
7172 if !self.table_infos.is_empty() {
7173 len += 1;
7174 }
7175 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
7176 if self.level_idx != 0 {
7177 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7178 }
7179 if self.level_type != 0 {
7180 let v = LevelType::try_from(self.level_type)
7181 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7182 struct_ser.serialize_field("levelType", &v)?;
7183 }
7184 if !self.table_infos.is_empty() {
7185 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7186 }
7187 struct_ser.end()
7188 }
7189}
7190impl<'de> serde::Deserialize<'de> for InputLevel {
7191 #[allow(deprecated)]
7192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7193 where
7194 D: serde::Deserializer<'de>,
7195 {
7196 const FIELDS: &[&str] = &[
7197 "level_idx",
7198 "levelIdx",
7199 "level_type",
7200 "levelType",
7201 "table_infos",
7202 "tableInfos",
7203 ];
7204
7205 #[allow(clippy::enum_variant_names)]
7206 enum GeneratedField {
7207 LevelIdx,
7208 LevelType,
7209 TableInfos,
7210 }
7211 impl<'de> serde::Deserialize<'de> for GeneratedField {
7212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7213 where
7214 D: serde::Deserializer<'de>,
7215 {
7216 struct GeneratedVisitor;
7217
7218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7219 type Value = GeneratedField;
7220
7221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7222 write!(formatter, "expected one of: {:?}", &FIELDS)
7223 }
7224
7225 #[allow(unused_variables)]
7226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7227 where
7228 E: serde::de::Error,
7229 {
7230 match value {
7231 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7232 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
7233 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
7234 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7235 }
7236 }
7237 }
7238 deserializer.deserialize_identifier(GeneratedVisitor)
7239 }
7240 }
7241 struct GeneratedVisitor;
7242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7243 type Value = InputLevel;
7244
7245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7246 formatter.write_str("struct hummock.InputLevel")
7247 }
7248
7249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
7250 where
7251 V: serde::de::MapAccess<'de>,
7252 {
7253 let mut level_idx__ = None;
7254 let mut level_type__ = None;
7255 let mut table_infos__ = None;
7256 while let Some(k) = map_.next_key()? {
7257 match k {
7258 GeneratedField::LevelIdx => {
7259 if level_idx__.is_some() {
7260 return Err(serde::de::Error::duplicate_field("levelIdx"));
7261 }
7262 level_idx__ =
7263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7264 ;
7265 }
7266 GeneratedField::LevelType => {
7267 if level_type__.is_some() {
7268 return Err(serde::de::Error::duplicate_field("levelType"));
7269 }
7270 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
7271 }
7272 GeneratedField::TableInfos => {
7273 if table_infos__.is_some() {
7274 return Err(serde::de::Error::duplicate_field("tableInfos"));
7275 }
7276 table_infos__ = Some(map_.next_value()?);
7277 }
7278 }
7279 }
7280 Ok(InputLevel {
7281 level_idx: level_idx__.unwrap_or_default(),
7282 level_type: level_type__.unwrap_or_default(),
7283 table_infos: table_infos__.unwrap_or_default(),
7284 })
7285 }
7286 }
7287 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
7288 }
7289}
7290impl serde::Serialize for IntraLevelDelta {
7291 #[allow(deprecated)]
7292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7293 where
7294 S: serde::Serializer,
7295 {
7296 use serde::ser::SerializeStruct;
7297 let mut len = 0;
7298 if self.level_idx != 0 {
7299 len += 1;
7300 }
7301 if self.l0_sub_level_id != 0 {
7302 len += 1;
7303 }
7304 if !self.removed_table_ids.is_empty() {
7305 len += 1;
7306 }
7307 if !self.inserted_table_infos.is_empty() {
7308 len += 1;
7309 }
7310 if self.vnode_partition_count != 0 {
7311 len += 1;
7312 }
7313 if self.compaction_group_version_id != 0 {
7314 len += 1;
7315 }
7316 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
7317 if self.level_idx != 0 {
7318 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7319 }
7320 if self.l0_sub_level_id != 0 {
7321 #[allow(clippy::needless_borrow)]
7322 #[allow(clippy::needless_borrows_for_generic_args)]
7323 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
7324 }
7325 if !self.removed_table_ids.is_empty() {
7326 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7327 }
7328 if !self.inserted_table_infos.is_empty() {
7329 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
7330 }
7331 if self.vnode_partition_count != 0 {
7332 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7333 }
7334 if self.compaction_group_version_id != 0 {
7335 #[allow(clippy::needless_borrow)]
7336 #[allow(clippy::needless_borrows_for_generic_args)]
7337 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
7338 }
7339 struct_ser.end()
7340 }
7341}
7342impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
7343 #[allow(deprecated)]
7344 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7345 where
7346 D: serde::Deserializer<'de>,
7347 {
7348 const FIELDS: &[&str] = &[
7349 "level_idx",
7350 "levelIdx",
7351 "l0_sub_level_id",
7352 "l0SubLevelId",
7353 "removed_table_ids",
7354 "removedTableIds",
7355 "inserted_table_infos",
7356 "insertedTableInfos",
7357 "vnode_partition_count",
7358 "vnodePartitionCount",
7359 "compaction_group_version_id",
7360 "compactionGroupVersionId",
7361 ];
7362
7363 #[allow(clippy::enum_variant_names)]
7364 enum GeneratedField {
7365 LevelIdx,
7366 L0SubLevelId,
7367 RemovedTableIds,
7368 InsertedTableInfos,
7369 VnodePartitionCount,
7370 CompactionGroupVersionId,
7371 }
7372 impl<'de> serde::Deserialize<'de> for GeneratedField {
7373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7374 where
7375 D: serde::Deserializer<'de>,
7376 {
7377 struct GeneratedVisitor;
7378
7379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7380 type Value = GeneratedField;
7381
7382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7383 write!(formatter, "expected one of: {:?}", &FIELDS)
7384 }
7385
7386 #[allow(unused_variables)]
7387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7388 where
7389 E: serde::de::Error,
7390 {
7391 match value {
7392 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7393 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
7394 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7395 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
7396 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7397 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
7398 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7399 }
7400 }
7401 }
7402 deserializer.deserialize_identifier(GeneratedVisitor)
7403 }
7404 }
7405 struct GeneratedVisitor;
7406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7407 type Value = IntraLevelDelta;
7408
7409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7410 formatter.write_str("struct hummock.IntraLevelDelta")
7411 }
7412
7413 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
7414 where
7415 V: serde::de::MapAccess<'de>,
7416 {
7417 let mut level_idx__ = None;
7418 let mut l0_sub_level_id__ = None;
7419 let mut removed_table_ids__ = None;
7420 let mut inserted_table_infos__ = None;
7421 let mut vnode_partition_count__ = None;
7422 let mut compaction_group_version_id__ = None;
7423 while let Some(k) = map_.next_key()? {
7424 match k {
7425 GeneratedField::LevelIdx => {
7426 if level_idx__.is_some() {
7427 return Err(serde::de::Error::duplicate_field("levelIdx"));
7428 }
7429 level_idx__ =
7430 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7431 ;
7432 }
7433 GeneratedField::L0SubLevelId => {
7434 if l0_sub_level_id__.is_some() {
7435 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
7436 }
7437 l0_sub_level_id__ =
7438 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7439 ;
7440 }
7441 GeneratedField::RemovedTableIds => {
7442 if removed_table_ids__.is_some() {
7443 return Err(serde::de::Error::duplicate_field("removedTableIds"));
7444 }
7445 removed_table_ids__ =
7446 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7447 .into_iter().map(|x| x.0).collect())
7448 ;
7449 }
7450 GeneratedField::InsertedTableInfos => {
7451 if inserted_table_infos__.is_some() {
7452 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
7453 }
7454 inserted_table_infos__ = Some(map_.next_value()?);
7455 }
7456 GeneratedField::VnodePartitionCount => {
7457 if vnode_partition_count__.is_some() {
7458 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7459 }
7460 vnode_partition_count__ =
7461 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7462 ;
7463 }
7464 GeneratedField::CompactionGroupVersionId => {
7465 if compaction_group_version_id__.is_some() {
7466 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
7467 }
7468 compaction_group_version_id__ =
7469 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7470 ;
7471 }
7472 }
7473 }
7474 Ok(IntraLevelDelta {
7475 level_idx: level_idx__.unwrap_or_default(),
7476 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
7477 removed_table_ids: removed_table_ids__.unwrap_or_default(),
7478 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
7479 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7480 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
7481 })
7482 }
7483 }
7484 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
7485 }
7486}
7487impl serde::Serialize for KeyRange {
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.left.is_empty() {
7496 len += 1;
7497 }
7498 if !self.right.is_empty() {
7499 len += 1;
7500 }
7501 if self.right_exclusive {
7502 len += 1;
7503 }
7504 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
7505 if !self.left.is_empty() {
7506 #[allow(clippy::needless_borrow)]
7507 #[allow(clippy::needless_borrows_for_generic_args)]
7508 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
7509 }
7510 if !self.right.is_empty() {
7511 #[allow(clippy::needless_borrow)]
7512 #[allow(clippy::needless_borrows_for_generic_args)]
7513 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
7514 }
7515 if self.right_exclusive {
7516 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
7517 }
7518 struct_ser.end()
7519 }
7520}
7521impl<'de> serde::Deserialize<'de> for KeyRange {
7522 #[allow(deprecated)]
7523 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7524 where
7525 D: serde::Deserializer<'de>,
7526 {
7527 const FIELDS: &[&str] = &[
7528 "left",
7529 "right",
7530 "right_exclusive",
7531 "rightExclusive",
7532 ];
7533
7534 #[allow(clippy::enum_variant_names)]
7535 enum GeneratedField {
7536 Left,
7537 Right,
7538 RightExclusive,
7539 }
7540 impl<'de> serde::Deserialize<'de> for GeneratedField {
7541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7542 where
7543 D: serde::Deserializer<'de>,
7544 {
7545 struct GeneratedVisitor;
7546
7547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7548 type Value = GeneratedField;
7549
7550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7551 write!(formatter, "expected one of: {:?}", &FIELDS)
7552 }
7553
7554 #[allow(unused_variables)]
7555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7556 where
7557 E: serde::de::Error,
7558 {
7559 match value {
7560 "left" => Ok(GeneratedField::Left),
7561 "right" => Ok(GeneratedField::Right),
7562 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
7563 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7564 }
7565 }
7566 }
7567 deserializer.deserialize_identifier(GeneratedVisitor)
7568 }
7569 }
7570 struct GeneratedVisitor;
7571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7572 type Value = KeyRange;
7573
7574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7575 formatter.write_str("struct hummock.KeyRange")
7576 }
7577
7578 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
7579 where
7580 V: serde::de::MapAccess<'de>,
7581 {
7582 let mut left__ = None;
7583 let mut right__ = None;
7584 let mut right_exclusive__ = None;
7585 while let Some(k) = map_.next_key()? {
7586 match k {
7587 GeneratedField::Left => {
7588 if left__.is_some() {
7589 return Err(serde::de::Error::duplicate_field("left"));
7590 }
7591 left__ =
7592 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7593 ;
7594 }
7595 GeneratedField::Right => {
7596 if right__.is_some() {
7597 return Err(serde::de::Error::duplicate_field("right"));
7598 }
7599 right__ =
7600 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7601 ;
7602 }
7603 GeneratedField::RightExclusive => {
7604 if right_exclusive__.is_some() {
7605 return Err(serde::de::Error::duplicate_field("rightExclusive"));
7606 }
7607 right_exclusive__ = Some(map_.next_value()?);
7608 }
7609 }
7610 }
7611 Ok(KeyRange {
7612 left: left__.unwrap_or_default(),
7613 right: right__.unwrap_or_default(),
7614 right_exclusive: right_exclusive__.unwrap_or_default(),
7615 })
7616 }
7617 }
7618 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
7619 }
7620}
7621impl serde::Serialize for Level {
7622 #[allow(deprecated)]
7623 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7624 where
7625 S: serde::Serializer,
7626 {
7627 use serde::ser::SerializeStruct;
7628 let mut len = 0;
7629 if self.level_idx != 0 {
7630 len += 1;
7631 }
7632 if self.level_type != 0 {
7633 len += 1;
7634 }
7635 if !self.table_infos.is_empty() {
7636 len += 1;
7637 }
7638 if self.total_file_size != 0 {
7639 len += 1;
7640 }
7641 if self.sub_level_id != 0 {
7642 len += 1;
7643 }
7644 if self.uncompressed_file_size != 0 {
7645 len += 1;
7646 }
7647 if self.vnode_partition_count != 0 {
7648 len += 1;
7649 }
7650 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
7651 if self.level_idx != 0 {
7652 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7653 }
7654 if self.level_type != 0 {
7655 let v = LevelType::try_from(self.level_type)
7656 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7657 struct_ser.serialize_field("levelType", &v)?;
7658 }
7659 if !self.table_infos.is_empty() {
7660 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7661 }
7662 if self.total_file_size != 0 {
7663 #[allow(clippy::needless_borrow)]
7664 #[allow(clippy::needless_borrows_for_generic_args)]
7665 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7666 }
7667 if self.sub_level_id != 0 {
7668 #[allow(clippy::needless_borrow)]
7669 #[allow(clippy::needless_borrows_for_generic_args)]
7670 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
7671 }
7672 if self.uncompressed_file_size != 0 {
7673 #[allow(clippy::needless_borrow)]
7674 #[allow(clippy::needless_borrows_for_generic_args)]
7675 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
7676 }
7677 if self.vnode_partition_count != 0 {
7678 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7679 }
7680 struct_ser.end()
7681 }
7682}
7683impl<'de> serde::Deserialize<'de> for Level {
7684 #[allow(deprecated)]
7685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7686 where
7687 D: serde::Deserializer<'de>,
7688 {
7689 const FIELDS: &[&str] = &[
7690 "level_idx",
7691 "levelIdx",
7692 "level_type",
7693 "levelType",
7694 "table_infos",
7695 "tableInfos",
7696 "total_file_size",
7697 "totalFileSize",
7698 "sub_level_id",
7699 "subLevelId",
7700 "uncompressed_file_size",
7701 "uncompressedFileSize",
7702 "vnode_partition_count",
7703 "vnodePartitionCount",
7704 ];
7705
7706 #[allow(clippy::enum_variant_names)]
7707 enum GeneratedField {
7708 LevelIdx,
7709 LevelType,
7710 TableInfos,
7711 TotalFileSize,
7712 SubLevelId,
7713 UncompressedFileSize,
7714 VnodePartitionCount,
7715 }
7716 impl<'de> serde::Deserialize<'de> for GeneratedField {
7717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7718 where
7719 D: serde::Deserializer<'de>,
7720 {
7721 struct GeneratedVisitor;
7722
7723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7724 type Value = GeneratedField;
7725
7726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7727 write!(formatter, "expected one of: {:?}", &FIELDS)
7728 }
7729
7730 #[allow(unused_variables)]
7731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7732 where
7733 E: serde::de::Error,
7734 {
7735 match value {
7736 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7737 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
7738 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
7739 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7740 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
7741 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
7742 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7743 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7744 }
7745 }
7746 }
7747 deserializer.deserialize_identifier(GeneratedVisitor)
7748 }
7749 }
7750 struct GeneratedVisitor;
7751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7752 type Value = Level;
7753
7754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7755 formatter.write_str("struct hummock.Level")
7756 }
7757
7758 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
7759 where
7760 V: serde::de::MapAccess<'de>,
7761 {
7762 let mut level_idx__ = None;
7763 let mut level_type__ = None;
7764 let mut table_infos__ = None;
7765 let mut total_file_size__ = None;
7766 let mut sub_level_id__ = None;
7767 let mut uncompressed_file_size__ = None;
7768 let mut vnode_partition_count__ = None;
7769 while let Some(k) = map_.next_key()? {
7770 match k {
7771 GeneratedField::LevelIdx => {
7772 if level_idx__.is_some() {
7773 return Err(serde::de::Error::duplicate_field("levelIdx"));
7774 }
7775 level_idx__ =
7776 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7777 ;
7778 }
7779 GeneratedField::LevelType => {
7780 if level_type__.is_some() {
7781 return Err(serde::de::Error::duplicate_field("levelType"));
7782 }
7783 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
7784 }
7785 GeneratedField::TableInfos => {
7786 if table_infos__.is_some() {
7787 return Err(serde::de::Error::duplicate_field("tableInfos"));
7788 }
7789 table_infos__ = Some(map_.next_value()?);
7790 }
7791 GeneratedField::TotalFileSize => {
7792 if total_file_size__.is_some() {
7793 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7794 }
7795 total_file_size__ =
7796 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7797 ;
7798 }
7799 GeneratedField::SubLevelId => {
7800 if sub_level_id__.is_some() {
7801 return Err(serde::de::Error::duplicate_field("subLevelId"));
7802 }
7803 sub_level_id__ =
7804 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7805 ;
7806 }
7807 GeneratedField::UncompressedFileSize => {
7808 if uncompressed_file_size__.is_some() {
7809 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
7810 }
7811 uncompressed_file_size__ =
7812 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7813 ;
7814 }
7815 GeneratedField::VnodePartitionCount => {
7816 if vnode_partition_count__.is_some() {
7817 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7818 }
7819 vnode_partition_count__ =
7820 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7821 ;
7822 }
7823 }
7824 }
7825 Ok(Level {
7826 level_idx: level_idx__.unwrap_or_default(),
7827 level_type: level_type__.unwrap_or_default(),
7828 table_infos: table_infos__.unwrap_or_default(),
7829 total_file_size: total_file_size__.unwrap_or_default(),
7830 sub_level_id: sub_level_id__.unwrap_or_default(),
7831 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
7832 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7833 })
7834 }
7835 }
7836 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
7837 }
7838}
7839impl serde::Serialize for LevelHandler {
7840 #[allow(deprecated)]
7841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7842 where
7843 S: serde::Serializer,
7844 {
7845 use serde::ser::SerializeStruct;
7846 let mut len = 0;
7847 if self.level != 0 {
7848 len += 1;
7849 }
7850 if !self.tasks.is_empty() {
7851 len += 1;
7852 }
7853 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
7854 if self.level != 0 {
7855 struct_ser.serialize_field("level", &self.level)?;
7856 }
7857 if !self.tasks.is_empty() {
7858 struct_ser.serialize_field("tasks", &self.tasks)?;
7859 }
7860 struct_ser.end()
7861 }
7862}
7863impl<'de> serde::Deserialize<'de> for LevelHandler {
7864 #[allow(deprecated)]
7865 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7866 where
7867 D: serde::Deserializer<'de>,
7868 {
7869 const FIELDS: &[&str] = &[
7870 "level",
7871 "tasks",
7872 ];
7873
7874 #[allow(clippy::enum_variant_names)]
7875 enum GeneratedField {
7876 Level,
7877 Tasks,
7878 }
7879 impl<'de> serde::Deserialize<'de> for GeneratedField {
7880 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7881 where
7882 D: serde::Deserializer<'de>,
7883 {
7884 struct GeneratedVisitor;
7885
7886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7887 type Value = GeneratedField;
7888
7889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7890 write!(formatter, "expected one of: {:?}", &FIELDS)
7891 }
7892
7893 #[allow(unused_variables)]
7894 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7895 where
7896 E: serde::de::Error,
7897 {
7898 match value {
7899 "level" => Ok(GeneratedField::Level),
7900 "tasks" => Ok(GeneratedField::Tasks),
7901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7902 }
7903 }
7904 }
7905 deserializer.deserialize_identifier(GeneratedVisitor)
7906 }
7907 }
7908 struct GeneratedVisitor;
7909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7910 type Value = LevelHandler;
7911
7912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7913 formatter.write_str("struct hummock.LevelHandler")
7914 }
7915
7916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
7917 where
7918 V: serde::de::MapAccess<'de>,
7919 {
7920 let mut level__ = None;
7921 let mut tasks__ = None;
7922 while let Some(k) = map_.next_key()? {
7923 match k {
7924 GeneratedField::Level => {
7925 if level__.is_some() {
7926 return Err(serde::de::Error::duplicate_field("level"));
7927 }
7928 level__ =
7929 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7930 ;
7931 }
7932 GeneratedField::Tasks => {
7933 if tasks__.is_some() {
7934 return Err(serde::de::Error::duplicate_field("tasks"));
7935 }
7936 tasks__ = Some(map_.next_value()?);
7937 }
7938 }
7939 }
7940 Ok(LevelHandler {
7941 level: level__.unwrap_or_default(),
7942 tasks: tasks__.unwrap_or_default(),
7943 })
7944 }
7945 }
7946 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
7947 }
7948}
7949impl serde::Serialize for level_handler::RunningCompactTask {
7950 #[allow(deprecated)]
7951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7952 where
7953 S: serde::Serializer,
7954 {
7955 use serde::ser::SerializeStruct;
7956 let mut len = 0;
7957 if self.task_id != 0 {
7958 len += 1;
7959 }
7960 if !self.ssts.is_empty() {
7961 len += 1;
7962 }
7963 if self.total_file_size != 0 {
7964 len += 1;
7965 }
7966 if self.target_level != 0 {
7967 len += 1;
7968 }
7969 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
7970 if self.task_id != 0 {
7971 #[allow(clippy::needless_borrow)]
7972 #[allow(clippy::needless_borrows_for_generic_args)]
7973 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7974 }
7975 if !self.ssts.is_empty() {
7976 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7977 }
7978 if self.total_file_size != 0 {
7979 #[allow(clippy::needless_borrow)]
7980 #[allow(clippy::needless_borrows_for_generic_args)]
7981 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7982 }
7983 if self.target_level != 0 {
7984 struct_ser.serialize_field("targetLevel", &self.target_level)?;
7985 }
7986 struct_ser.end()
7987 }
7988}
7989impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
7990 #[allow(deprecated)]
7991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7992 where
7993 D: serde::Deserializer<'de>,
7994 {
7995 const FIELDS: &[&str] = &[
7996 "task_id",
7997 "taskId",
7998 "ssts",
7999 "total_file_size",
8000 "totalFileSize",
8001 "target_level",
8002 "targetLevel",
8003 ];
8004
8005 #[allow(clippy::enum_variant_names)]
8006 enum GeneratedField {
8007 TaskId,
8008 Ssts,
8009 TotalFileSize,
8010 TargetLevel,
8011 }
8012 impl<'de> serde::Deserialize<'de> for GeneratedField {
8013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8014 where
8015 D: serde::Deserializer<'de>,
8016 {
8017 struct GeneratedVisitor;
8018
8019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8020 type Value = GeneratedField;
8021
8022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8023 write!(formatter, "expected one of: {:?}", &FIELDS)
8024 }
8025
8026 #[allow(unused_variables)]
8027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8028 where
8029 E: serde::de::Error,
8030 {
8031 match value {
8032 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8033 "ssts" => Ok(GeneratedField::Ssts),
8034 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8035 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
8036 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8037 }
8038 }
8039 }
8040 deserializer.deserialize_identifier(GeneratedVisitor)
8041 }
8042 }
8043 struct GeneratedVisitor;
8044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8045 type Value = level_handler::RunningCompactTask;
8046
8047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8048 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
8049 }
8050
8051 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
8052 where
8053 V: serde::de::MapAccess<'de>,
8054 {
8055 let mut task_id__ = None;
8056 let mut ssts__ = None;
8057 let mut total_file_size__ = None;
8058 let mut target_level__ = None;
8059 while let Some(k) = map_.next_key()? {
8060 match k {
8061 GeneratedField::TaskId => {
8062 if task_id__.is_some() {
8063 return Err(serde::de::Error::duplicate_field("taskId"));
8064 }
8065 task_id__ =
8066 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8067 ;
8068 }
8069 GeneratedField::Ssts => {
8070 if ssts__.is_some() {
8071 return Err(serde::de::Error::duplicate_field("ssts"));
8072 }
8073 ssts__ =
8074 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8075 .into_iter().map(|x| x.0).collect())
8076 ;
8077 }
8078 GeneratedField::TotalFileSize => {
8079 if total_file_size__.is_some() {
8080 return Err(serde::de::Error::duplicate_field("totalFileSize"));
8081 }
8082 total_file_size__ =
8083 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8084 ;
8085 }
8086 GeneratedField::TargetLevel => {
8087 if target_level__.is_some() {
8088 return Err(serde::de::Error::duplicate_field("targetLevel"));
8089 }
8090 target_level__ =
8091 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8092 ;
8093 }
8094 }
8095 }
8096 Ok(level_handler::RunningCompactTask {
8097 task_id: task_id__.unwrap_or_default(),
8098 ssts: ssts__.unwrap_or_default(),
8099 total_file_size: total_file_size__.unwrap_or_default(),
8100 target_level: target_level__.unwrap_or_default(),
8101 })
8102 }
8103 }
8104 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
8105 }
8106}
8107impl serde::Serialize for LevelType {
8108 #[allow(deprecated)]
8109 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8110 where
8111 S: serde::Serializer,
8112 {
8113 let variant = match self {
8114 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
8115 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
8116 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
8117 };
8118 serializer.serialize_str(variant)
8119 }
8120}
8121impl<'de> serde::Deserialize<'de> for LevelType {
8122 #[allow(deprecated)]
8123 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8124 where
8125 D: serde::Deserializer<'de>,
8126 {
8127 const FIELDS: &[&str] = &[
8128 "LEVEL_TYPE_UNSPECIFIED",
8129 "LEVEL_TYPE_NONOVERLAPPING",
8130 "LEVEL_TYPE_OVERLAPPING",
8131 ];
8132
8133 struct GeneratedVisitor;
8134
8135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8136 type Value = LevelType;
8137
8138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8139 write!(formatter, "expected one of: {:?}", &FIELDS)
8140 }
8141
8142 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8143 where
8144 E: serde::de::Error,
8145 {
8146 i32::try_from(v)
8147 .ok()
8148 .and_then(|x| x.try_into().ok())
8149 .ok_or_else(|| {
8150 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8151 })
8152 }
8153
8154 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8155 where
8156 E: serde::de::Error,
8157 {
8158 i32::try_from(v)
8159 .ok()
8160 .and_then(|x| x.try_into().ok())
8161 .ok_or_else(|| {
8162 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8163 })
8164 }
8165
8166 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8167 where
8168 E: serde::de::Error,
8169 {
8170 match value {
8171 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
8172 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
8173 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
8174 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8175 }
8176 }
8177 }
8178 deserializer.deserialize_any(GeneratedVisitor)
8179 }
8180}
8181impl serde::Serialize for ListActiveWriteLimitRequest {
8182 #[allow(deprecated)]
8183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8184 where
8185 S: serde::Serializer,
8186 {
8187 use serde::ser::SerializeStruct;
8188 let len = 0;
8189 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
8190 struct_ser.end()
8191 }
8192}
8193impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
8194 #[allow(deprecated)]
8195 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8196 where
8197 D: serde::Deserializer<'de>,
8198 {
8199 const FIELDS: &[&str] = &[
8200 ];
8201
8202 #[allow(clippy::enum_variant_names)]
8203 enum GeneratedField {
8204 }
8205 impl<'de> serde::Deserialize<'de> for GeneratedField {
8206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8207 where
8208 D: serde::Deserializer<'de>,
8209 {
8210 struct GeneratedVisitor;
8211
8212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8213 type Value = GeneratedField;
8214
8215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8216 write!(formatter, "expected one of: {:?}", &FIELDS)
8217 }
8218
8219 #[allow(unused_variables)]
8220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8221 where
8222 E: serde::de::Error,
8223 {
8224 Err(serde::de::Error::unknown_field(value, FIELDS))
8225 }
8226 }
8227 deserializer.deserialize_identifier(GeneratedVisitor)
8228 }
8229 }
8230 struct GeneratedVisitor;
8231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8232 type Value = ListActiveWriteLimitRequest;
8233
8234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8235 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
8236 }
8237
8238 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
8239 where
8240 V: serde::de::MapAccess<'de>,
8241 {
8242 while map_.next_key::<GeneratedField>()?.is_some() {
8243 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8244 }
8245 Ok(ListActiveWriteLimitRequest {
8246 })
8247 }
8248 }
8249 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
8250 }
8251}
8252impl serde::Serialize for ListActiveWriteLimitResponse {
8253 #[allow(deprecated)]
8254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8255 where
8256 S: serde::Serializer,
8257 {
8258 use serde::ser::SerializeStruct;
8259 let mut len = 0;
8260 if !self.write_limits.is_empty() {
8261 len += 1;
8262 }
8263 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
8264 if !self.write_limits.is_empty() {
8265 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
8266 }
8267 struct_ser.end()
8268 }
8269}
8270impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
8271 #[allow(deprecated)]
8272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8273 where
8274 D: serde::Deserializer<'de>,
8275 {
8276 const FIELDS: &[&str] = &[
8277 "write_limits",
8278 "writeLimits",
8279 ];
8280
8281 #[allow(clippy::enum_variant_names)]
8282 enum GeneratedField {
8283 WriteLimits,
8284 }
8285 impl<'de> serde::Deserialize<'de> for GeneratedField {
8286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8287 where
8288 D: serde::Deserializer<'de>,
8289 {
8290 struct GeneratedVisitor;
8291
8292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8293 type Value = GeneratedField;
8294
8295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8296 write!(formatter, "expected one of: {:?}", &FIELDS)
8297 }
8298
8299 #[allow(unused_variables)]
8300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8301 where
8302 E: serde::de::Error,
8303 {
8304 match value {
8305 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
8306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8307 }
8308 }
8309 }
8310 deserializer.deserialize_identifier(GeneratedVisitor)
8311 }
8312 }
8313 struct GeneratedVisitor;
8314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8315 type Value = ListActiveWriteLimitResponse;
8316
8317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8318 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
8319 }
8320
8321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
8322 where
8323 V: serde::de::MapAccess<'de>,
8324 {
8325 let mut write_limits__ = None;
8326 while let Some(k) = map_.next_key()? {
8327 match k {
8328 GeneratedField::WriteLimits => {
8329 if write_limits__.is_some() {
8330 return Err(serde::de::Error::duplicate_field("writeLimits"));
8331 }
8332 write_limits__ = Some(
8333 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
8334 .into_iter().map(|(k,v)| (k.0, v)).collect()
8335 );
8336 }
8337 }
8338 }
8339 Ok(ListActiveWriteLimitResponse {
8340 write_limits: write_limits__.unwrap_or_default(),
8341 })
8342 }
8343 }
8344 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
8345 }
8346}
8347impl serde::Serialize for ListBranchedObjectRequest {
8348 #[allow(deprecated)]
8349 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8350 where
8351 S: serde::Serializer,
8352 {
8353 use serde::ser::SerializeStruct;
8354 let len = 0;
8355 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
8356 struct_ser.end()
8357 }
8358}
8359impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
8360 #[allow(deprecated)]
8361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8362 where
8363 D: serde::Deserializer<'de>,
8364 {
8365 const FIELDS: &[&str] = &[
8366 ];
8367
8368 #[allow(clippy::enum_variant_names)]
8369 enum GeneratedField {
8370 }
8371 impl<'de> serde::Deserialize<'de> for GeneratedField {
8372 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8373 where
8374 D: serde::Deserializer<'de>,
8375 {
8376 struct GeneratedVisitor;
8377
8378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8379 type Value = GeneratedField;
8380
8381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8382 write!(formatter, "expected one of: {:?}", &FIELDS)
8383 }
8384
8385 #[allow(unused_variables)]
8386 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8387 where
8388 E: serde::de::Error,
8389 {
8390 Err(serde::de::Error::unknown_field(value, FIELDS))
8391 }
8392 }
8393 deserializer.deserialize_identifier(GeneratedVisitor)
8394 }
8395 }
8396 struct GeneratedVisitor;
8397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8398 type Value = ListBranchedObjectRequest;
8399
8400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8401 formatter.write_str("struct hummock.ListBranchedObjectRequest")
8402 }
8403
8404 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
8405 where
8406 V: serde::de::MapAccess<'de>,
8407 {
8408 while map_.next_key::<GeneratedField>()?.is_some() {
8409 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8410 }
8411 Ok(ListBranchedObjectRequest {
8412 })
8413 }
8414 }
8415 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
8416 }
8417}
8418impl serde::Serialize for ListBranchedObjectResponse {
8419 #[allow(deprecated)]
8420 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8421 where
8422 S: serde::Serializer,
8423 {
8424 use serde::ser::SerializeStruct;
8425 let mut len = 0;
8426 if !self.branched_objects.is_empty() {
8427 len += 1;
8428 }
8429 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
8430 if !self.branched_objects.is_empty() {
8431 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
8432 }
8433 struct_ser.end()
8434 }
8435}
8436impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
8437 #[allow(deprecated)]
8438 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8439 where
8440 D: serde::Deserializer<'de>,
8441 {
8442 const FIELDS: &[&str] = &[
8443 "branched_objects",
8444 "branchedObjects",
8445 ];
8446
8447 #[allow(clippy::enum_variant_names)]
8448 enum GeneratedField {
8449 BranchedObjects,
8450 }
8451 impl<'de> serde::Deserialize<'de> for GeneratedField {
8452 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8453 where
8454 D: serde::Deserializer<'de>,
8455 {
8456 struct GeneratedVisitor;
8457
8458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8459 type Value = GeneratedField;
8460
8461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8462 write!(formatter, "expected one of: {:?}", &FIELDS)
8463 }
8464
8465 #[allow(unused_variables)]
8466 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8467 where
8468 E: serde::de::Error,
8469 {
8470 match value {
8471 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
8472 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8473 }
8474 }
8475 }
8476 deserializer.deserialize_identifier(GeneratedVisitor)
8477 }
8478 }
8479 struct GeneratedVisitor;
8480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8481 type Value = ListBranchedObjectResponse;
8482
8483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8484 formatter.write_str("struct hummock.ListBranchedObjectResponse")
8485 }
8486
8487 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
8488 where
8489 V: serde::de::MapAccess<'de>,
8490 {
8491 let mut branched_objects__ = None;
8492 while let Some(k) = map_.next_key()? {
8493 match k {
8494 GeneratedField::BranchedObjects => {
8495 if branched_objects__.is_some() {
8496 return Err(serde::de::Error::duplicate_field("branchedObjects"));
8497 }
8498 branched_objects__ = Some(map_.next_value()?);
8499 }
8500 }
8501 }
8502 Ok(ListBranchedObjectResponse {
8503 branched_objects: branched_objects__.unwrap_or_default(),
8504 })
8505 }
8506 }
8507 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
8508 }
8509}
8510impl serde::Serialize for ListCompactTaskAssignmentRequest {
8511 #[allow(deprecated)]
8512 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8513 where
8514 S: serde::Serializer,
8515 {
8516 use serde::ser::SerializeStruct;
8517 let len = 0;
8518 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
8519 struct_ser.end()
8520 }
8521}
8522impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
8523 #[allow(deprecated)]
8524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8525 where
8526 D: serde::Deserializer<'de>,
8527 {
8528 const FIELDS: &[&str] = &[
8529 ];
8530
8531 #[allow(clippy::enum_variant_names)]
8532 enum GeneratedField {
8533 }
8534 impl<'de> serde::Deserialize<'de> for GeneratedField {
8535 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8536 where
8537 D: serde::Deserializer<'de>,
8538 {
8539 struct GeneratedVisitor;
8540
8541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8542 type Value = GeneratedField;
8543
8544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8545 write!(formatter, "expected one of: {:?}", &FIELDS)
8546 }
8547
8548 #[allow(unused_variables)]
8549 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8550 where
8551 E: serde::de::Error,
8552 {
8553 Err(serde::de::Error::unknown_field(value, FIELDS))
8554 }
8555 }
8556 deserializer.deserialize_identifier(GeneratedVisitor)
8557 }
8558 }
8559 struct GeneratedVisitor;
8560 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8561 type Value = ListCompactTaskAssignmentRequest;
8562
8563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8564 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
8565 }
8566
8567 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
8568 where
8569 V: serde::de::MapAccess<'de>,
8570 {
8571 while map_.next_key::<GeneratedField>()?.is_some() {
8572 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8573 }
8574 Ok(ListCompactTaskAssignmentRequest {
8575 })
8576 }
8577 }
8578 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
8579 }
8580}
8581impl serde::Serialize for ListCompactTaskAssignmentResponse {
8582 #[allow(deprecated)]
8583 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8584 where
8585 S: serde::Serializer,
8586 {
8587 use serde::ser::SerializeStruct;
8588 let mut len = 0;
8589 if !self.task_assignment.is_empty() {
8590 len += 1;
8591 }
8592 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
8593 if !self.task_assignment.is_empty() {
8594 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
8595 }
8596 struct_ser.end()
8597 }
8598}
8599impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
8600 #[allow(deprecated)]
8601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8602 where
8603 D: serde::Deserializer<'de>,
8604 {
8605 const FIELDS: &[&str] = &[
8606 "task_assignment",
8607 "taskAssignment",
8608 ];
8609
8610 #[allow(clippy::enum_variant_names)]
8611 enum GeneratedField {
8612 TaskAssignment,
8613 }
8614 impl<'de> serde::Deserialize<'de> for GeneratedField {
8615 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8616 where
8617 D: serde::Deserializer<'de>,
8618 {
8619 struct GeneratedVisitor;
8620
8621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8622 type Value = GeneratedField;
8623
8624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8625 write!(formatter, "expected one of: {:?}", &FIELDS)
8626 }
8627
8628 #[allow(unused_variables)]
8629 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8630 where
8631 E: serde::de::Error,
8632 {
8633 match value {
8634 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
8635 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8636 }
8637 }
8638 }
8639 deserializer.deserialize_identifier(GeneratedVisitor)
8640 }
8641 }
8642 struct GeneratedVisitor;
8643 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8644 type Value = ListCompactTaskAssignmentResponse;
8645
8646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8647 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
8648 }
8649
8650 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
8651 where
8652 V: serde::de::MapAccess<'de>,
8653 {
8654 let mut task_assignment__ = None;
8655 while let Some(k) = map_.next_key()? {
8656 match k {
8657 GeneratedField::TaskAssignment => {
8658 if task_assignment__.is_some() {
8659 return Err(serde::de::Error::duplicate_field("taskAssignment"));
8660 }
8661 task_assignment__ = Some(map_.next_value()?);
8662 }
8663 }
8664 }
8665 Ok(ListCompactTaskAssignmentResponse {
8666 task_assignment: task_assignment__.unwrap_or_default(),
8667 })
8668 }
8669 }
8670 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
8671 }
8672}
8673impl serde::Serialize for ListCompactTaskProgressRequest {
8674 #[allow(deprecated)]
8675 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8676 where
8677 S: serde::Serializer,
8678 {
8679 use serde::ser::SerializeStruct;
8680 let len = 0;
8681 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
8682 struct_ser.end()
8683 }
8684}
8685impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
8686 #[allow(deprecated)]
8687 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8688 where
8689 D: serde::Deserializer<'de>,
8690 {
8691 const FIELDS: &[&str] = &[
8692 ];
8693
8694 #[allow(clippy::enum_variant_names)]
8695 enum GeneratedField {
8696 }
8697 impl<'de> serde::Deserialize<'de> for GeneratedField {
8698 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8699 where
8700 D: serde::Deserializer<'de>,
8701 {
8702 struct GeneratedVisitor;
8703
8704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8705 type Value = GeneratedField;
8706
8707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8708 write!(formatter, "expected one of: {:?}", &FIELDS)
8709 }
8710
8711 #[allow(unused_variables)]
8712 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8713 where
8714 E: serde::de::Error,
8715 {
8716 Err(serde::de::Error::unknown_field(value, FIELDS))
8717 }
8718 }
8719 deserializer.deserialize_identifier(GeneratedVisitor)
8720 }
8721 }
8722 struct GeneratedVisitor;
8723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8724 type Value = ListCompactTaskProgressRequest;
8725
8726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8727 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
8728 }
8729
8730 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
8731 where
8732 V: serde::de::MapAccess<'de>,
8733 {
8734 while map_.next_key::<GeneratedField>()?.is_some() {
8735 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8736 }
8737 Ok(ListCompactTaskProgressRequest {
8738 })
8739 }
8740 }
8741 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
8742 }
8743}
8744impl serde::Serialize for ListCompactTaskProgressResponse {
8745 #[allow(deprecated)]
8746 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8747 where
8748 S: serde::Serializer,
8749 {
8750 use serde::ser::SerializeStruct;
8751 let mut len = 0;
8752 if !self.task_progress.is_empty() {
8753 len += 1;
8754 }
8755 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
8756 if !self.task_progress.is_empty() {
8757 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
8758 }
8759 struct_ser.end()
8760 }
8761}
8762impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
8763 #[allow(deprecated)]
8764 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8765 where
8766 D: serde::Deserializer<'de>,
8767 {
8768 const FIELDS: &[&str] = &[
8769 "task_progress",
8770 "taskProgress",
8771 ];
8772
8773 #[allow(clippy::enum_variant_names)]
8774 enum GeneratedField {
8775 TaskProgress,
8776 }
8777 impl<'de> serde::Deserialize<'de> for GeneratedField {
8778 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8779 where
8780 D: serde::Deserializer<'de>,
8781 {
8782 struct GeneratedVisitor;
8783
8784 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8785 type Value = GeneratedField;
8786
8787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8788 write!(formatter, "expected one of: {:?}", &FIELDS)
8789 }
8790
8791 #[allow(unused_variables)]
8792 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8793 where
8794 E: serde::de::Error,
8795 {
8796 match value {
8797 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
8798 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8799 }
8800 }
8801 }
8802 deserializer.deserialize_identifier(GeneratedVisitor)
8803 }
8804 }
8805 struct GeneratedVisitor;
8806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8807 type Value = ListCompactTaskProgressResponse;
8808
8809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8810 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
8811 }
8812
8813 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
8814 where
8815 V: serde::de::MapAccess<'de>,
8816 {
8817 let mut task_progress__ = None;
8818 while let Some(k) = map_.next_key()? {
8819 match k {
8820 GeneratedField::TaskProgress => {
8821 if task_progress__.is_some() {
8822 return Err(serde::de::Error::duplicate_field("taskProgress"));
8823 }
8824 task_progress__ = Some(map_.next_value()?);
8825 }
8826 }
8827 }
8828 Ok(ListCompactTaskProgressResponse {
8829 task_progress: task_progress__.unwrap_or_default(),
8830 })
8831 }
8832 }
8833 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
8834 }
8835}
8836impl serde::Serialize for ListHummockMetaConfigRequest {
8837 #[allow(deprecated)]
8838 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8839 where
8840 S: serde::Serializer,
8841 {
8842 use serde::ser::SerializeStruct;
8843 let len = 0;
8844 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
8845 struct_ser.end()
8846 }
8847}
8848impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
8849 #[allow(deprecated)]
8850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8851 where
8852 D: serde::Deserializer<'de>,
8853 {
8854 const FIELDS: &[&str] = &[
8855 ];
8856
8857 #[allow(clippy::enum_variant_names)]
8858 enum GeneratedField {
8859 }
8860 impl<'de> serde::Deserialize<'de> for GeneratedField {
8861 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8862 where
8863 D: serde::Deserializer<'de>,
8864 {
8865 struct GeneratedVisitor;
8866
8867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8868 type Value = GeneratedField;
8869
8870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8871 write!(formatter, "expected one of: {:?}", &FIELDS)
8872 }
8873
8874 #[allow(unused_variables)]
8875 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8876 where
8877 E: serde::de::Error,
8878 {
8879 Err(serde::de::Error::unknown_field(value, FIELDS))
8880 }
8881 }
8882 deserializer.deserialize_identifier(GeneratedVisitor)
8883 }
8884 }
8885 struct GeneratedVisitor;
8886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8887 type Value = ListHummockMetaConfigRequest;
8888
8889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8890 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
8891 }
8892
8893 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
8894 where
8895 V: serde::de::MapAccess<'de>,
8896 {
8897 while map_.next_key::<GeneratedField>()?.is_some() {
8898 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8899 }
8900 Ok(ListHummockMetaConfigRequest {
8901 })
8902 }
8903 }
8904 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
8905 }
8906}
8907impl serde::Serialize for ListHummockMetaConfigResponse {
8908 #[allow(deprecated)]
8909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8910 where
8911 S: serde::Serializer,
8912 {
8913 use serde::ser::SerializeStruct;
8914 let mut len = 0;
8915 if !self.configs.is_empty() {
8916 len += 1;
8917 }
8918 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
8919 if !self.configs.is_empty() {
8920 struct_ser.serialize_field("configs", &self.configs)?;
8921 }
8922 struct_ser.end()
8923 }
8924}
8925impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
8926 #[allow(deprecated)]
8927 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8928 where
8929 D: serde::Deserializer<'de>,
8930 {
8931 const FIELDS: &[&str] = &[
8932 "configs",
8933 ];
8934
8935 #[allow(clippy::enum_variant_names)]
8936 enum GeneratedField {
8937 Configs,
8938 }
8939 impl<'de> serde::Deserialize<'de> for GeneratedField {
8940 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8941 where
8942 D: serde::Deserializer<'de>,
8943 {
8944 struct GeneratedVisitor;
8945
8946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8947 type Value = GeneratedField;
8948
8949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8950 write!(formatter, "expected one of: {:?}", &FIELDS)
8951 }
8952
8953 #[allow(unused_variables)]
8954 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8955 where
8956 E: serde::de::Error,
8957 {
8958 match value {
8959 "configs" => Ok(GeneratedField::Configs),
8960 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8961 }
8962 }
8963 }
8964 deserializer.deserialize_identifier(GeneratedVisitor)
8965 }
8966 }
8967 struct GeneratedVisitor;
8968 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8969 type Value = ListHummockMetaConfigResponse;
8970
8971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8972 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
8973 }
8974
8975 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
8976 where
8977 V: serde::de::MapAccess<'de>,
8978 {
8979 let mut configs__ = None;
8980 while let Some(k) = map_.next_key()? {
8981 match k {
8982 GeneratedField::Configs => {
8983 if configs__.is_some() {
8984 return Err(serde::de::Error::duplicate_field("configs"));
8985 }
8986 configs__ = Some(
8987 map_.next_value::<std::collections::HashMap<_, _>>()?
8988 );
8989 }
8990 }
8991 }
8992 Ok(ListHummockMetaConfigResponse {
8993 configs: configs__.unwrap_or_default(),
8994 })
8995 }
8996 }
8997 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
8998 }
8999}
9000impl serde::Serialize for ListVersionDeltasRequest {
9001 #[allow(deprecated)]
9002 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9003 where
9004 S: serde::Serializer,
9005 {
9006 use serde::ser::SerializeStruct;
9007 let mut len = 0;
9008 if self.start_id != 0 {
9009 len += 1;
9010 }
9011 if self.num_limit != 0 {
9012 len += 1;
9013 }
9014 if self.committed_epoch_limit != 0 {
9015 len += 1;
9016 }
9017 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
9018 if self.start_id != 0 {
9019 #[allow(clippy::needless_borrow)]
9020 #[allow(clippy::needless_borrows_for_generic_args)]
9021 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
9022 }
9023 if self.num_limit != 0 {
9024 struct_ser.serialize_field("numLimit", &self.num_limit)?;
9025 }
9026 if self.committed_epoch_limit != 0 {
9027 #[allow(clippy::needless_borrow)]
9028 #[allow(clippy::needless_borrows_for_generic_args)]
9029 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
9030 }
9031 struct_ser.end()
9032 }
9033}
9034impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
9035 #[allow(deprecated)]
9036 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9037 where
9038 D: serde::Deserializer<'de>,
9039 {
9040 const FIELDS: &[&str] = &[
9041 "start_id",
9042 "startId",
9043 "num_limit",
9044 "numLimit",
9045 "committed_epoch_limit",
9046 "committedEpochLimit",
9047 ];
9048
9049 #[allow(clippy::enum_variant_names)]
9050 enum GeneratedField {
9051 StartId,
9052 NumLimit,
9053 CommittedEpochLimit,
9054 }
9055 impl<'de> serde::Deserialize<'de> for GeneratedField {
9056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9057 where
9058 D: serde::Deserializer<'de>,
9059 {
9060 struct GeneratedVisitor;
9061
9062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9063 type Value = GeneratedField;
9064
9065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9066 write!(formatter, "expected one of: {:?}", &FIELDS)
9067 }
9068
9069 #[allow(unused_variables)]
9070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9071 where
9072 E: serde::de::Error,
9073 {
9074 match value {
9075 "startId" | "start_id" => Ok(GeneratedField::StartId),
9076 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
9077 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
9078 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9079 }
9080 }
9081 }
9082 deserializer.deserialize_identifier(GeneratedVisitor)
9083 }
9084 }
9085 struct GeneratedVisitor;
9086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9087 type Value = ListVersionDeltasRequest;
9088
9089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9090 formatter.write_str("struct hummock.ListVersionDeltasRequest")
9091 }
9092
9093 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
9094 where
9095 V: serde::de::MapAccess<'de>,
9096 {
9097 let mut start_id__ = None;
9098 let mut num_limit__ = None;
9099 let mut committed_epoch_limit__ = None;
9100 while let Some(k) = map_.next_key()? {
9101 match k {
9102 GeneratedField::StartId => {
9103 if start_id__.is_some() {
9104 return Err(serde::de::Error::duplicate_field("startId"));
9105 }
9106 start_id__ =
9107 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9108 ;
9109 }
9110 GeneratedField::NumLimit => {
9111 if num_limit__.is_some() {
9112 return Err(serde::de::Error::duplicate_field("numLimit"));
9113 }
9114 num_limit__ =
9115 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9116 ;
9117 }
9118 GeneratedField::CommittedEpochLimit => {
9119 if committed_epoch_limit__.is_some() {
9120 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
9121 }
9122 committed_epoch_limit__ =
9123 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9124 ;
9125 }
9126 }
9127 }
9128 Ok(ListVersionDeltasRequest {
9129 start_id: start_id__.unwrap_or_default(),
9130 num_limit: num_limit__.unwrap_or_default(),
9131 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
9132 })
9133 }
9134 }
9135 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
9136 }
9137}
9138impl serde::Serialize for ListVersionDeltasResponse {
9139 #[allow(deprecated)]
9140 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9141 where
9142 S: serde::Serializer,
9143 {
9144 use serde::ser::SerializeStruct;
9145 let mut len = 0;
9146 if self.version_deltas.is_some() {
9147 len += 1;
9148 }
9149 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
9150 if let Some(v) = self.version_deltas.as_ref() {
9151 struct_ser.serialize_field("versionDeltas", v)?;
9152 }
9153 struct_ser.end()
9154 }
9155}
9156impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
9157 #[allow(deprecated)]
9158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9159 where
9160 D: serde::Deserializer<'de>,
9161 {
9162 const FIELDS: &[&str] = &[
9163 "version_deltas",
9164 "versionDeltas",
9165 ];
9166
9167 #[allow(clippy::enum_variant_names)]
9168 enum GeneratedField {
9169 VersionDeltas,
9170 }
9171 impl<'de> serde::Deserialize<'de> for GeneratedField {
9172 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9173 where
9174 D: serde::Deserializer<'de>,
9175 {
9176 struct GeneratedVisitor;
9177
9178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9179 type Value = GeneratedField;
9180
9181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9182 write!(formatter, "expected one of: {:?}", &FIELDS)
9183 }
9184
9185 #[allow(unused_variables)]
9186 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9187 where
9188 E: serde::de::Error,
9189 {
9190 match value {
9191 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
9192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9193 }
9194 }
9195 }
9196 deserializer.deserialize_identifier(GeneratedVisitor)
9197 }
9198 }
9199 struct GeneratedVisitor;
9200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9201 type Value = ListVersionDeltasResponse;
9202
9203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9204 formatter.write_str("struct hummock.ListVersionDeltasResponse")
9205 }
9206
9207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
9208 where
9209 V: serde::de::MapAccess<'de>,
9210 {
9211 let mut version_deltas__ = None;
9212 while let Some(k) = map_.next_key()? {
9213 match k {
9214 GeneratedField::VersionDeltas => {
9215 if version_deltas__.is_some() {
9216 return Err(serde::de::Error::duplicate_field("versionDeltas"));
9217 }
9218 version_deltas__ = map_.next_value()?;
9219 }
9220 }
9221 }
9222 Ok(ListVersionDeltasResponse {
9223 version_deltas: version_deltas__,
9224 })
9225 }
9226 }
9227 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
9228 }
9229}
9230impl serde::Serialize for MergeCompactionGroupRequest {
9231 #[allow(deprecated)]
9232 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9233 where
9234 S: serde::Serializer,
9235 {
9236 use serde::ser::SerializeStruct;
9237 let mut len = 0;
9238 if self.left_group_id != 0 {
9239 len += 1;
9240 }
9241 if self.right_group_id != 0 {
9242 len += 1;
9243 }
9244 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
9245 if self.left_group_id != 0 {
9246 #[allow(clippy::needless_borrow)]
9247 #[allow(clippy::needless_borrows_for_generic_args)]
9248 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
9249 }
9250 if self.right_group_id != 0 {
9251 #[allow(clippy::needless_borrow)]
9252 #[allow(clippy::needless_borrows_for_generic_args)]
9253 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
9254 }
9255 struct_ser.end()
9256 }
9257}
9258impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
9259 #[allow(deprecated)]
9260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9261 where
9262 D: serde::Deserializer<'de>,
9263 {
9264 const FIELDS: &[&str] = &[
9265 "left_group_id",
9266 "leftGroupId",
9267 "right_group_id",
9268 "rightGroupId",
9269 ];
9270
9271 #[allow(clippy::enum_variant_names)]
9272 enum GeneratedField {
9273 LeftGroupId,
9274 RightGroupId,
9275 }
9276 impl<'de> serde::Deserialize<'de> for GeneratedField {
9277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9278 where
9279 D: serde::Deserializer<'de>,
9280 {
9281 struct GeneratedVisitor;
9282
9283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9284 type Value = GeneratedField;
9285
9286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9287 write!(formatter, "expected one of: {:?}", &FIELDS)
9288 }
9289
9290 #[allow(unused_variables)]
9291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9292 where
9293 E: serde::de::Error,
9294 {
9295 match value {
9296 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
9297 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
9298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9299 }
9300 }
9301 }
9302 deserializer.deserialize_identifier(GeneratedVisitor)
9303 }
9304 }
9305 struct GeneratedVisitor;
9306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9307 type Value = MergeCompactionGroupRequest;
9308
9309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9310 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
9311 }
9312
9313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
9314 where
9315 V: serde::de::MapAccess<'de>,
9316 {
9317 let mut left_group_id__ = None;
9318 let mut right_group_id__ = None;
9319 while let Some(k) = map_.next_key()? {
9320 match k {
9321 GeneratedField::LeftGroupId => {
9322 if left_group_id__.is_some() {
9323 return Err(serde::de::Error::duplicate_field("leftGroupId"));
9324 }
9325 left_group_id__ =
9326 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9327 ;
9328 }
9329 GeneratedField::RightGroupId => {
9330 if right_group_id__.is_some() {
9331 return Err(serde::de::Error::duplicate_field("rightGroupId"));
9332 }
9333 right_group_id__ =
9334 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9335 ;
9336 }
9337 }
9338 }
9339 Ok(MergeCompactionGroupRequest {
9340 left_group_id: left_group_id__.unwrap_or_default(),
9341 right_group_id: right_group_id__.unwrap_or_default(),
9342 })
9343 }
9344 }
9345 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
9346 }
9347}
9348impl serde::Serialize for MergeCompactionGroupResponse {
9349 #[allow(deprecated)]
9350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9351 where
9352 S: serde::Serializer,
9353 {
9354 use serde::ser::SerializeStruct;
9355 let len = 0;
9356 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
9357 struct_ser.end()
9358 }
9359}
9360impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
9361 #[allow(deprecated)]
9362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9363 where
9364 D: serde::Deserializer<'de>,
9365 {
9366 const FIELDS: &[&str] = &[
9367 ];
9368
9369 #[allow(clippy::enum_variant_names)]
9370 enum GeneratedField {
9371 }
9372 impl<'de> serde::Deserialize<'de> for GeneratedField {
9373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9374 where
9375 D: serde::Deserializer<'de>,
9376 {
9377 struct GeneratedVisitor;
9378
9379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9380 type Value = GeneratedField;
9381
9382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9383 write!(formatter, "expected one of: {:?}", &FIELDS)
9384 }
9385
9386 #[allow(unused_variables)]
9387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9388 where
9389 E: serde::de::Error,
9390 {
9391 Err(serde::de::Error::unknown_field(value, FIELDS))
9392 }
9393 }
9394 deserializer.deserialize_identifier(GeneratedVisitor)
9395 }
9396 }
9397 struct GeneratedVisitor;
9398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9399 type Value = MergeCompactionGroupResponse;
9400
9401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9402 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
9403 }
9404
9405 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
9406 where
9407 V: serde::de::MapAccess<'de>,
9408 {
9409 while map_.next_key::<GeneratedField>()?.is_some() {
9410 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9411 }
9412 Ok(MergeCompactionGroupResponse {
9413 })
9414 }
9415 }
9416 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
9417 }
9418}
9419impl serde::Serialize for NewL0SubLevel {
9420 #[allow(deprecated)]
9421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9422 where
9423 S: serde::Serializer,
9424 {
9425 use serde::ser::SerializeStruct;
9426 let mut len = 0;
9427 if !self.inserted_table_infos.is_empty() {
9428 len += 1;
9429 }
9430 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
9431 if !self.inserted_table_infos.is_empty() {
9432 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
9433 }
9434 struct_ser.end()
9435 }
9436}
9437impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
9438 #[allow(deprecated)]
9439 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9440 where
9441 D: serde::Deserializer<'de>,
9442 {
9443 const FIELDS: &[&str] = &[
9444 "inserted_table_infos",
9445 "insertedTableInfos",
9446 ];
9447
9448 #[allow(clippy::enum_variant_names)]
9449 enum GeneratedField {
9450 InsertedTableInfos,
9451 }
9452 impl<'de> serde::Deserialize<'de> for GeneratedField {
9453 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9454 where
9455 D: serde::Deserializer<'de>,
9456 {
9457 struct GeneratedVisitor;
9458
9459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9460 type Value = GeneratedField;
9461
9462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9463 write!(formatter, "expected one of: {:?}", &FIELDS)
9464 }
9465
9466 #[allow(unused_variables)]
9467 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9468 where
9469 E: serde::de::Error,
9470 {
9471 match value {
9472 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
9473 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9474 }
9475 }
9476 }
9477 deserializer.deserialize_identifier(GeneratedVisitor)
9478 }
9479 }
9480 struct GeneratedVisitor;
9481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9482 type Value = NewL0SubLevel;
9483
9484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9485 formatter.write_str("struct hummock.NewL0SubLevel")
9486 }
9487
9488 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
9489 where
9490 V: serde::de::MapAccess<'de>,
9491 {
9492 let mut inserted_table_infos__ = None;
9493 while let Some(k) = map_.next_key()? {
9494 match k {
9495 GeneratedField::InsertedTableInfos => {
9496 if inserted_table_infos__.is_some() {
9497 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
9498 }
9499 inserted_table_infos__ = Some(map_.next_value()?);
9500 }
9501 }
9502 }
9503 Ok(NewL0SubLevel {
9504 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
9505 })
9506 }
9507 }
9508 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
9509 }
9510}
9511impl serde::Serialize for OverlappingLevel {
9512 #[allow(deprecated)]
9513 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9514 where
9515 S: serde::Serializer,
9516 {
9517 use serde::ser::SerializeStruct;
9518 let mut len = 0;
9519 if !self.sub_levels.is_empty() {
9520 len += 1;
9521 }
9522 if self.total_file_size != 0 {
9523 len += 1;
9524 }
9525 if self.uncompressed_file_size != 0 {
9526 len += 1;
9527 }
9528 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
9529 if !self.sub_levels.is_empty() {
9530 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
9531 }
9532 if self.total_file_size != 0 {
9533 #[allow(clippy::needless_borrow)]
9534 #[allow(clippy::needless_borrows_for_generic_args)]
9535 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9536 }
9537 if self.uncompressed_file_size != 0 {
9538 #[allow(clippy::needless_borrow)]
9539 #[allow(clippy::needless_borrows_for_generic_args)]
9540 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
9541 }
9542 struct_ser.end()
9543 }
9544}
9545impl<'de> serde::Deserialize<'de> for OverlappingLevel {
9546 #[allow(deprecated)]
9547 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9548 where
9549 D: serde::Deserializer<'de>,
9550 {
9551 const FIELDS: &[&str] = &[
9552 "sub_levels",
9553 "subLevels",
9554 "total_file_size",
9555 "totalFileSize",
9556 "uncompressed_file_size",
9557 "uncompressedFileSize",
9558 ];
9559
9560 #[allow(clippy::enum_variant_names)]
9561 enum GeneratedField {
9562 SubLevels,
9563 TotalFileSize,
9564 UncompressedFileSize,
9565 }
9566 impl<'de> serde::Deserialize<'de> for GeneratedField {
9567 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9568 where
9569 D: serde::Deserializer<'de>,
9570 {
9571 struct GeneratedVisitor;
9572
9573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9574 type Value = GeneratedField;
9575
9576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9577 write!(formatter, "expected one of: {:?}", &FIELDS)
9578 }
9579
9580 #[allow(unused_variables)]
9581 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9582 where
9583 E: serde::de::Error,
9584 {
9585 match value {
9586 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
9587 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9588 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
9589 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9590 }
9591 }
9592 }
9593 deserializer.deserialize_identifier(GeneratedVisitor)
9594 }
9595 }
9596 struct GeneratedVisitor;
9597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9598 type Value = OverlappingLevel;
9599
9600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9601 formatter.write_str("struct hummock.OverlappingLevel")
9602 }
9603
9604 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
9605 where
9606 V: serde::de::MapAccess<'de>,
9607 {
9608 let mut sub_levels__ = None;
9609 let mut total_file_size__ = None;
9610 let mut uncompressed_file_size__ = None;
9611 while let Some(k) = map_.next_key()? {
9612 match k {
9613 GeneratedField::SubLevels => {
9614 if sub_levels__.is_some() {
9615 return Err(serde::de::Error::duplicate_field("subLevels"));
9616 }
9617 sub_levels__ = Some(map_.next_value()?);
9618 }
9619 GeneratedField::TotalFileSize => {
9620 if total_file_size__.is_some() {
9621 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9622 }
9623 total_file_size__ =
9624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9625 ;
9626 }
9627 GeneratedField::UncompressedFileSize => {
9628 if uncompressed_file_size__.is_some() {
9629 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
9630 }
9631 uncompressed_file_size__ =
9632 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9633 ;
9634 }
9635 }
9636 }
9637 Ok(OverlappingLevel {
9638 sub_levels: sub_levels__.unwrap_or_default(),
9639 total_file_size: total_file_size__.unwrap_or_default(),
9640 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
9641 })
9642 }
9643 }
9644 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
9645 }
9646}
9647impl serde::Serialize for PinVersionRequest {
9648 #[allow(deprecated)]
9649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9650 where
9651 S: serde::Serializer,
9652 {
9653 use serde::ser::SerializeStruct;
9654 let mut len = 0;
9655 if self.context_id != 0 {
9656 len += 1;
9657 }
9658 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
9659 if self.context_id != 0 {
9660 struct_ser.serialize_field("contextId", &self.context_id)?;
9661 }
9662 struct_ser.end()
9663 }
9664}
9665impl<'de> serde::Deserialize<'de> for PinVersionRequest {
9666 #[allow(deprecated)]
9667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9668 where
9669 D: serde::Deserializer<'de>,
9670 {
9671 const FIELDS: &[&str] = &[
9672 "context_id",
9673 "contextId",
9674 ];
9675
9676 #[allow(clippy::enum_variant_names)]
9677 enum GeneratedField {
9678 ContextId,
9679 }
9680 impl<'de> serde::Deserialize<'de> for GeneratedField {
9681 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9682 where
9683 D: serde::Deserializer<'de>,
9684 {
9685 struct GeneratedVisitor;
9686
9687 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9688 type Value = GeneratedField;
9689
9690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9691 write!(formatter, "expected one of: {:?}", &FIELDS)
9692 }
9693
9694 #[allow(unused_variables)]
9695 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9696 where
9697 E: serde::de::Error,
9698 {
9699 match value {
9700 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
9701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9702 }
9703 }
9704 }
9705 deserializer.deserialize_identifier(GeneratedVisitor)
9706 }
9707 }
9708 struct GeneratedVisitor;
9709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9710 type Value = PinVersionRequest;
9711
9712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9713 formatter.write_str("struct hummock.PinVersionRequest")
9714 }
9715
9716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
9717 where
9718 V: serde::de::MapAccess<'de>,
9719 {
9720 let mut context_id__ = None;
9721 while let Some(k) = map_.next_key()? {
9722 match k {
9723 GeneratedField::ContextId => {
9724 if context_id__.is_some() {
9725 return Err(serde::de::Error::duplicate_field("contextId"));
9726 }
9727 context_id__ =
9728 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9729 ;
9730 }
9731 }
9732 }
9733 Ok(PinVersionRequest {
9734 context_id: context_id__.unwrap_or_default(),
9735 })
9736 }
9737 }
9738 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
9739 }
9740}
9741impl serde::Serialize for PinVersionResponse {
9742 #[allow(deprecated)]
9743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9744 where
9745 S: serde::Serializer,
9746 {
9747 use serde::ser::SerializeStruct;
9748 let mut len = 0;
9749 if self.pinned_version.is_some() {
9750 len += 1;
9751 }
9752 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
9753 if let Some(v) = self.pinned_version.as_ref() {
9754 struct_ser.serialize_field("pinnedVersion", v)?;
9755 }
9756 struct_ser.end()
9757 }
9758}
9759impl<'de> serde::Deserialize<'de> for PinVersionResponse {
9760 #[allow(deprecated)]
9761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9762 where
9763 D: serde::Deserializer<'de>,
9764 {
9765 const FIELDS: &[&str] = &[
9766 "pinned_version",
9767 "pinnedVersion",
9768 ];
9769
9770 #[allow(clippy::enum_variant_names)]
9771 enum GeneratedField {
9772 PinnedVersion,
9773 }
9774 impl<'de> serde::Deserialize<'de> for GeneratedField {
9775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9776 where
9777 D: serde::Deserializer<'de>,
9778 {
9779 struct GeneratedVisitor;
9780
9781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9782 type Value = GeneratedField;
9783
9784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9785 write!(formatter, "expected one of: {:?}", &FIELDS)
9786 }
9787
9788 #[allow(unused_variables)]
9789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9790 where
9791 E: serde::de::Error,
9792 {
9793 match value {
9794 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
9795 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9796 }
9797 }
9798 }
9799 deserializer.deserialize_identifier(GeneratedVisitor)
9800 }
9801 }
9802 struct GeneratedVisitor;
9803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9804 type Value = PinVersionResponse;
9805
9806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9807 formatter.write_str("struct hummock.PinVersionResponse")
9808 }
9809
9810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
9811 where
9812 V: serde::de::MapAccess<'de>,
9813 {
9814 let mut pinned_version__ = None;
9815 while let Some(k) = map_.next_key()? {
9816 match k {
9817 GeneratedField::PinnedVersion => {
9818 if pinned_version__.is_some() {
9819 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
9820 }
9821 pinned_version__ = map_.next_value()?;
9822 }
9823 }
9824 }
9825 Ok(PinVersionResponse {
9826 pinned_version: pinned_version__,
9827 })
9828 }
9829 }
9830 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
9831 }
9832}
9833impl serde::Serialize for PinnedVersionsSummary {
9834 #[allow(deprecated)]
9835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9836 where
9837 S: serde::Serializer,
9838 {
9839 use serde::ser::SerializeStruct;
9840 let mut len = 0;
9841 if !self.pinned_versions.is_empty() {
9842 len += 1;
9843 }
9844 if !self.workers.is_empty() {
9845 len += 1;
9846 }
9847 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
9848 if !self.pinned_versions.is_empty() {
9849 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
9850 }
9851 if !self.workers.is_empty() {
9852 struct_ser.serialize_field("workers", &self.workers)?;
9853 }
9854 struct_ser.end()
9855 }
9856}
9857impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
9858 #[allow(deprecated)]
9859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9860 where
9861 D: serde::Deserializer<'de>,
9862 {
9863 const FIELDS: &[&str] = &[
9864 "pinned_versions",
9865 "pinnedVersions",
9866 "workers",
9867 ];
9868
9869 #[allow(clippy::enum_variant_names)]
9870 enum GeneratedField {
9871 PinnedVersions,
9872 Workers,
9873 }
9874 impl<'de> serde::Deserialize<'de> for GeneratedField {
9875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9876 where
9877 D: serde::Deserializer<'de>,
9878 {
9879 struct GeneratedVisitor;
9880
9881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9882 type Value = GeneratedField;
9883
9884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9885 write!(formatter, "expected one of: {:?}", &FIELDS)
9886 }
9887
9888 #[allow(unused_variables)]
9889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9890 where
9891 E: serde::de::Error,
9892 {
9893 match value {
9894 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
9895 "workers" => Ok(GeneratedField::Workers),
9896 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9897 }
9898 }
9899 }
9900 deserializer.deserialize_identifier(GeneratedVisitor)
9901 }
9902 }
9903 struct GeneratedVisitor;
9904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9905 type Value = PinnedVersionsSummary;
9906
9907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9908 formatter.write_str("struct hummock.PinnedVersionsSummary")
9909 }
9910
9911 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
9912 where
9913 V: serde::de::MapAccess<'de>,
9914 {
9915 let mut pinned_versions__ = None;
9916 let mut workers__ = None;
9917 while let Some(k) = map_.next_key()? {
9918 match k {
9919 GeneratedField::PinnedVersions => {
9920 if pinned_versions__.is_some() {
9921 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
9922 }
9923 pinned_versions__ = Some(map_.next_value()?);
9924 }
9925 GeneratedField::Workers => {
9926 if workers__.is_some() {
9927 return Err(serde::de::Error::duplicate_field("workers"));
9928 }
9929 workers__ = Some(
9930 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9931 .into_iter().map(|(k,v)| (k.0, v)).collect()
9932 );
9933 }
9934 }
9935 }
9936 Ok(PinnedVersionsSummary {
9937 pinned_versions: pinned_versions__.unwrap_or_default(),
9938 workers: workers__.unwrap_or_default(),
9939 })
9940 }
9941 }
9942 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
9943 }
9944}
9945impl serde::Serialize for ReplayVersionDeltaRequest {
9946 #[allow(deprecated)]
9947 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9948 where
9949 S: serde::Serializer,
9950 {
9951 use serde::ser::SerializeStruct;
9952 let mut len = 0;
9953 if self.version_delta.is_some() {
9954 len += 1;
9955 }
9956 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
9957 if let Some(v) = self.version_delta.as_ref() {
9958 struct_ser.serialize_field("versionDelta", v)?;
9959 }
9960 struct_ser.end()
9961 }
9962}
9963impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
9964 #[allow(deprecated)]
9965 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9966 where
9967 D: serde::Deserializer<'de>,
9968 {
9969 const FIELDS: &[&str] = &[
9970 "version_delta",
9971 "versionDelta",
9972 ];
9973
9974 #[allow(clippy::enum_variant_names)]
9975 enum GeneratedField {
9976 VersionDelta,
9977 }
9978 impl<'de> serde::Deserialize<'de> for GeneratedField {
9979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9980 where
9981 D: serde::Deserializer<'de>,
9982 {
9983 struct GeneratedVisitor;
9984
9985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9986 type Value = GeneratedField;
9987
9988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9989 write!(formatter, "expected one of: {:?}", &FIELDS)
9990 }
9991
9992 #[allow(unused_variables)]
9993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9994 where
9995 E: serde::de::Error,
9996 {
9997 match value {
9998 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
9999 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10000 }
10001 }
10002 }
10003 deserializer.deserialize_identifier(GeneratedVisitor)
10004 }
10005 }
10006 struct GeneratedVisitor;
10007 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10008 type Value = ReplayVersionDeltaRequest;
10009
10010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10011 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
10012 }
10013
10014 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
10015 where
10016 V: serde::de::MapAccess<'de>,
10017 {
10018 let mut version_delta__ = None;
10019 while let Some(k) = map_.next_key()? {
10020 match k {
10021 GeneratedField::VersionDelta => {
10022 if version_delta__.is_some() {
10023 return Err(serde::de::Error::duplicate_field("versionDelta"));
10024 }
10025 version_delta__ = map_.next_value()?;
10026 }
10027 }
10028 }
10029 Ok(ReplayVersionDeltaRequest {
10030 version_delta: version_delta__,
10031 })
10032 }
10033 }
10034 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
10035 }
10036}
10037impl serde::Serialize for ReplayVersionDeltaResponse {
10038 #[allow(deprecated)]
10039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10040 where
10041 S: serde::Serializer,
10042 {
10043 use serde::ser::SerializeStruct;
10044 let mut len = 0;
10045 if self.version.is_some() {
10046 len += 1;
10047 }
10048 if !self.modified_compaction_groups.is_empty() {
10049 len += 1;
10050 }
10051 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
10052 if let Some(v) = self.version.as_ref() {
10053 struct_ser.serialize_field("version", v)?;
10054 }
10055 if !self.modified_compaction_groups.is_empty() {
10056 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
10057 }
10058 struct_ser.end()
10059 }
10060}
10061impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
10062 #[allow(deprecated)]
10063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10064 where
10065 D: serde::Deserializer<'de>,
10066 {
10067 const FIELDS: &[&str] = &[
10068 "version",
10069 "modified_compaction_groups",
10070 "modifiedCompactionGroups",
10071 ];
10072
10073 #[allow(clippy::enum_variant_names)]
10074 enum GeneratedField {
10075 Version,
10076 ModifiedCompactionGroups,
10077 }
10078 impl<'de> serde::Deserialize<'de> for GeneratedField {
10079 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10080 where
10081 D: serde::Deserializer<'de>,
10082 {
10083 struct GeneratedVisitor;
10084
10085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10086 type Value = GeneratedField;
10087
10088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10089 write!(formatter, "expected one of: {:?}", &FIELDS)
10090 }
10091
10092 #[allow(unused_variables)]
10093 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10094 where
10095 E: serde::de::Error,
10096 {
10097 match value {
10098 "version" => Ok(GeneratedField::Version),
10099 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
10100 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10101 }
10102 }
10103 }
10104 deserializer.deserialize_identifier(GeneratedVisitor)
10105 }
10106 }
10107 struct GeneratedVisitor;
10108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10109 type Value = ReplayVersionDeltaResponse;
10110
10111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10112 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
10113 }
10114
10115 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
10116 where
10117 V: serde::de::MapAccess<'de>,
10118 {
10119 let mut version__ = None;
10120 let mut modified_compaction_groups__ = None;
10121 while let Some(k) = map_.next_key()? {
10122 match k {
10123 GeneratedField::Version => {
10124 if version__.is_some() {
10125 return Err(serde::de::Error::duplicate_field("version"));
10126 }
10127 version__ = map_.next_value()?;
10128 }
10129 GeneratedField::ModifiedCompactionGroups => {
10130 if modified_compaction_groups__.is_some() {
10131 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
10132 }
10133 modified_compaction_groups__ =
10134 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10135 .into_iter().map(|x| x.0).collect())
10136 ;
10137 }
10138 }
10139 }
10140 Ok(ReplayVersionDeltaResponse {
10141 version: version__,
10142 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
10143 })
10144 }
10145 }
10146 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
10147 }
10148}
10149impl serde::Serialize for ReportCompactionTaskRequest {
10150 #[allow(deprecated)]
10151 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10152 where
10153 S: serde::Serializer,
10154 {
10155 use serde::ser::SerializeStruct;
10156 let mut len = 0;
10157 if self.event.is_some() {
10158 len += 1;
10159 }
10160 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
10161 if let Some(v) = self.event.as_ref() {
10162 match v {
10163 report_compaction_task_request::Event::ReportTask(v) => {
10164 struct_ser.serialize_field("reportTask", v)?;
10165 }
10166 report_compaction_task_request::Event::HeartBeat(v) => {
10167 struct_ser.serialize_field("heartBeat", v)?;
10168 }
10169 }
10170 }
10171 struct_ser.end()
10172 }
10173}
10174impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
10175 #[allow(deprecated)]
10176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10177 where
10178 D: serde::Deserializer<'de>,
10179 {
10180 const FIELDS: &[&str] = &[
10181 "report_task",
10182 "reportTask",
10183 "heart_beat",
10184 "heartBeat",
10185 ];
10186
10187 #[allow(clippy::enum_variant_names)]
10188 enum GeneratedField {
10189 ReportTask,
10190 HeartBeat,
10191 }
10192 impl<'de> serde::Deserialize<'de> for GeneratedField {
10193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10194 where
10195 D: serde::Deserializer<'de>,
10196 {
10197 struct GeneratedVisitor;
10198
10199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10200 type Value = GeneratedField;
10201
10202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10203 write!(formatter, "expected one of: {:?}", &FIELDS)
10204 }
10205
10206 #[allow(unused_variables)]
10207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10208 where
10209 E: serde::de::Error,
10210 {
10211 match value {
10212 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
10213 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
10214 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10215 }
10216 }
10217 }
10218 deserializer.deserialize_identifier(GeneratedVisitor)
10219 }
10220 }
10221 struct GeneratedVisitor;
10222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10223 type Value = ReportCompactionTaskRequest;
10224
10225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10226 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
10227 }
10228
10229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
10230 where
10231 V: serde::de::MapAccess<'de>,
10232 {
10233 let mut event__ = None;
10234 while let Some(k) = map_.next_key()? {
10235 match k {
10236 GeneratedField::ReportTask => {
10237 if event__.is_some() {
10238 return Err(serde::de::Error::duplicate_field("reportTask"));
10239 }
10240 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
10241;
10242 }
10243 GeneratedField::HeartBeat => {
10244 if event__.is_some() {
10245 return Err(serde::de::Error::duplicate_field("heartBeat"));
10246 }
10247 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
10248;
10249 }
10250 }
10251 }
10252 Ok(ReportCompactionTaskRequest {
10253 event: event__,
10254 })
10255 }
10256 }
10257 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
10258 }
10259}
10260impl serde::Serialize for report_compaction_task_request::HeartBeat {
10261 #[allow(deprecated)]
10262 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10263 where
10264 S: serde::Serializer,
10265 {
10266 use serde::ser::SerializeStruct;
10267 let mut len = 0;
10268 if !self.progress.is_empty() {
10269 len += 1;
10270 }
10271 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
10272 if !self.progress.is_empty() {
10273 struct_ser.serialize_field("progress", &self.progress)?;
10274 }
10275 struct_ser.end()
10276 }
10277}
10278impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
10279 #[allow(deprecated)]
10280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10281 where
10282 D: serde::Deserializer<'de>,
10283 {
10284 const FIELDS: &[&str] = &[
10285 "progress",
10286 ];
10287
10288 #[allow(clippy::enum_variant_names)]
10289 enum GeneratedField {
10290 Progress,
10291 }
10292 impl<'de> serde::Deserialize<'de> for GeneratedField {
10293 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10294 where
10295 D: serde::Deserializer<'de>,
10296 {
10297 struct GeneratedVisitor;
10298
10299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10300 type Value = GeneratedField;
10301
10302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10303 write!(formatter, "expected one of: {:?}", &FIELDS)
10304 }
10305
10306 #[allow(unused_variables)]
10307 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10308 where
10309 E: serde::de::Error,
10310 {
10311 match value {
10312 "progress" => Ok(GeneratedField::Progress),
10313 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10314 }
10315 }
10316 }
10317 deserializer.deserialize_identifier(GeneratedVisitor)
10318 }
10319 }
10320 struct GeneratedVisitor;
10321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10322 type Value = report_compaction_task_request::HeartBeat;
10323
10324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10325 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
10326 }
10327
10328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
10329 where
10330 V: serde::de::MapAccess<'de>,
10331 {
10332 let mut progress__ = None;
10333 while let Some(k) = map_.next_key()? {
10334 match k {
10335 GeneratedField::Progress => {
10336 if progress__.is_some() {
10337 return Err(serde::de::Error::duplicate_field("progress"));
10338 }
10339 progress__ = Some(map_.next_value()?);
10340 }
10341 }
10342 }
10343 Ok(report_compaction_task_request::HeartBeat {
10344 progress: progress__.unwrap_or_default(),
10345 })
10346 }
10347 }
10348 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
10349 }
10350}
10351impl serde::Serialize for report_compaction_task_request::ReportTask {
10352 #[allow(deprecated)]
10353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10354 where
10355 S: serde::Serializer,
10356 {
10357 use serde::ser::SerializeStruct;
10358 let mut len = 0;
10359 if self.compact_task.is_some() {
10360 len += 1;
10361 }
10362 if !self.table_stats_change.is_empty() {
10363 len += 1;
10364 }
10365 if !self.object_timestamps.is_empty() {
10366 len += 1;
10367 }
10368 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
10369 if let Some(v) = self.compact_task.as_ref() {
10370 struct_ser.serialize_field("compactTask", v)?;
10371 }
10372 if !self.table_stats_change.is_empty() {
10373 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
10374 }
10375 if !self.object_timestamps.is_empty() {
10376 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
10377 .map(|(k, v)| (k, v.to_string())).collect();
10378 struct_ser.serialize_field("objectTimestamps", &v)?;
10379 }
10380 struct_ser.end()
10381 }
10382}
10383impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
10384 #[allow(deprecated)]
10385 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10386 where
10387 D: serde::Deserializer<'de>,
10388 {
10389 const FIELDS: &[&str] = &[
10390 "compact_task",
10391 "compactTask",
10392 "table_stats_change",
10393 "tableStatsChange",
10394 "object_timestamps",
10395 "objectTimestamps",
10396 ];
10397
10398 #[allow(clippy::enum_variant_names)]
10399 enum GeneratedField {
10400 CompactTask,
10401 TableStatsChange,
10402 ObjectTimestamps,
10403 }
10404 impl<'de> serde::Deserialize<'de> for GeneratedField {
10405 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10406 where
10407 D: serde::Deserializer<'de>,
10408 {
10409 struct GeneratedVisitor;
10410
10411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10412 type Value = GeneratedField;
10413
10414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10415 write!(formatter, "expected one of: {:?}", &FIELDS)
10416 }
10417
10418 #[allow(unused_variables)]
10419 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10420 where
10421 E: serde::de::Error,
10422 {
10423 match value {
10424 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
10425 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
10426 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
10427 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10428 }
10429 }
10430 }
10431 deserializer.deserialize_identifier(GeneratedVisitor)
10432 }
10433 }
10434 struct GeneratedVisitor;
10435 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10436 type Value = report_compaction_task_request::ReportTask;
10437
10438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10439 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
10440 }
10441
10442 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
10443 where
10444 V: serde::de::MapAccess<'de>,
10445 {
10446 let mut compact_task__ = None;
10447 let mut table_stats_change__ = None;
10448 let mut object_timestamps__ = None;
10449 while let Some(k) = map_.next_key()? {
10450 match k {
10451 GeneratedField::CompactTask => {
10452 if compact_task__.is_some() {
10453 return Err(serde::de::Error::duplicate_field("compactTask"));
10454 }
10455 compact_task__ = map_.next_value()?;
10456 }
10457 GeneratedField::TableStatsChange => {
10458 if table_stats_change__.is_some() {
10459 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
10460 }
10461 table_stats_change__ = Some(
10462 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10463 .into_iter().map(|(k,v)| (k.0, v)).collect()
10464 );
10465 }
10466 GeneratedField::ObjectTimestamps => {
10467 if object_timestamps__.is_some() {
10468 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
10469 }
10470 object_timestamps__ = Some(
10471 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
10472 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
10473 );
10474 }
10475 }
10476 }
10477 Ok(report_compaction_task_request::ReportTask {
10478 compact_task: compact_task__,
10479 table_stats_change: table_stats_change__.unwrap_or_default(),
10480 object_timestamps: object_timestamps__.unwrap_or_default(),
10481 })
10482 }
10483 }
10484 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
10485 }
10486}
10487impl serde::Serialize for ReportCompactionTaskResponse {
10488 #[allow(deprecated)]
10489 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10490 where
10491 S: serde::Serializer,
10492 {
10493 use serde::ser::SerializeStruct;
10494 let mut len = 0;
10495 if self.status.is_some() {
10496 len += 1;
10497 }
10498 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
10499 if let Some(v) = self.status.as_ref() {
10500 struct_ser.serialize_field("status", v)?;
10501 }
10502 struct_ser.end()
10503 }
10504}
10505impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
10506 #[allow(deprecated)]
10507 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10508 where
10509 D: serde::Deserializer<'de>,
10510 {
10511 const FIELDS: &[&str] = &[
10512 "status",
10513 ];
10514
10515 #[allow(clippy::enum_variant_names)]
10516 enum GeneratedField {
10517 Status,
10518 }
10519 impl<'de> serde::Deserialize<'de> for GeneratedField {
10520 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10521 where
10522 D: serde::Deserializer<'de>,
10523 {
10524 struct GeneratedVisitor;
10525
10526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10527 type Value = GeneratedField;
10528
10529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10530 write!(formatter, "expected one of: {:?}", &FIELDS)
10531 }
10532
10533 #[allow(unused_variables)]
10534 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10535 where
10536 E: serde::de::Error,
10537 {
10538 match value {
10539 "status" => Ok(GeneratedField::Status),
10540 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10541 }
10542 }
10543 }
10544 deserializer.deserialize_identifier(GeneratedVisitor)
10545 }
10546 }
10547 struct GeneratedVisitor;
10548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10549 type Value = ReportCompactionTaskResponse;
10550
10551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10552 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
10553 }
10554
10555 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
10556 where
10557 V: serde::de::MapAccess<'de>,
10558 {
10559 let mut status__ = None;
10560 while let Some(k) = map_.next_key()? {
10561 match k {
10562 GeneratedField::Status => {
10563 if status__.is_some() {
10564 return Err(serde::de::Error::duplicate_field("status"));
10565 }
10566 status__ = map_.next_value()?;
10567 }
10568 }
10569 }
10570 Ok(ReportCompactionTaskResponse {
10571 status: status__,
10572 })
10573 }
10574 }
10575 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
10576 }
10577}
10578impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
10579 #[allow(deprecated)]
10580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10581 where
10582 S: serde::Serializer,
10583 {
10584 use serde::ser::SerializeStruct;
10585 let len = 0;
10586 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
10587 struct_ser.end()
10588 }
10589}
10590impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
10591 #[allow(deprecated)]
10592 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10593 where
10594 D: serde::Deserializer<'de>,
10595 {
10596 const FIELDS: &[&str] = &[
10597 ];
10598
10599 #[allow(clippy::enum_variant_names)]
10600 enum GeneratedField {
10601 }
10602 impl<'de> serde::Deserialize<'de> for GeneratedField {
10603 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10604 where
10605 D: serde::Deserializer<'de>,
10606 {
10607 struct GeneratedVisitor;
10608
10609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10610 type Value = GeneratedField;
10611
10612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10613 write!(formatter, "expected one of: {:?}", &FIELDS)
10614 }
10615
10616 #[allow(unused_variables)]
10617 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10618 where
10619 E: serde::de::Error,
10620 {
10621 Err(serde::de::Error::unknown_field(value, FIELDS))
10622 }
10623 }
10624 deserializer.deserialize_identifier(GeneratedVisitor)
10625 }
10626 }
10627 struct GeneratedVisitor;
10628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10629 type Value = RiseCtlGetCheckpointVersionRequest;
10630
10631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10632 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
10633 }
10634
10635 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
10636 where
10637 V: serde::de::MapAccess<'de>,
10638 {
10639 while map_.next_key::<GeneratedField>()?.is_some() {
10640 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10641 }
10642 Ok(RiseCtlGetCheckpointVersionRequest {
10643 })
10644 }
10645 }
10646 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
10647 }
10648}
10649impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
10650 #[allow(deprecated)]
10651 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10652 where
10653 S: serde::Serializer,
10654 {
10655 use serde::ser::SerializeStruct;
10656 let mut len = 0;
10657 if self.checkpoint_version.is_some() {
10658 len += 1;
10659 }
10660 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
10661 if let Some(v) = self.checkpoint_version.as_ref() {
10662 struct_ser.serialize_field("checkpointVersion", v)?;
10663 }
10664 struct_ser.end()
10665 }
10666}
10667impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
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 "checkpoint_version",
10675 "checkpointVersion",
10676 ];
10677
10678 #[allow(clippy::enum_variant_names)]
10679 enum GeneratedField {
10680 CheckpointVersion,
10681 }
10682 impl<'de> serde::Deserialize<'de> for GeneratedField {
10683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10684 where
10685 D: serde::Deserializer<'de>,
10686 {
10687 struct GeneratedVisitor;
10688
10689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10690 type Value = GeneratedField;
10691
10692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10693 write!(formatter, "expected one of: {:?}", &FIELDS)
10694 }
10695
10696 #[allow(unused_variables)]
10697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10698 where
10699 E: serde::de::Error,
10700 {
10701 match value {
10702 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
10703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10704 }
10705 }
10706 }
10707 deserializer.deserialize_identifier(GeneratedVisitor)
10708 }
10709 }
10710 struct GeneratedVisitor;
10711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10712 type Value = RiseCtlGetCheckpointVersionResponse;
10713
10714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10715 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
10716 }
10717
10718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
10719 where
10720 V: serde::de::MapAccess<'de>,
10721 {
10722 let mut checkpoint_version__ = None;
10723 while let Some(k) = map_.next_key()? {
10724 match k {
10725 GeneratedField::CheckpointVersion => {
10726 if checkpoint_version__.is_some() {
10727 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
10728 }
10729 checkpoint_version__ = map_.next_value()?;
10730 }
10731 }
10732 }
10733 Ok(RiseCtlGetCheckpointVersionResponse {
10734 checkpoint_version: checkpoint_version__,
10735 })
10736 }
10737 }
10738 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
10739 }
10740}
10741impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
10742 #[allow(deprecated)]
10743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10744 where
10745 S: serde::Serializer,
10746 {
10747 use serde::ser::SerializeStruct;
10748 let len = 0;
10749 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
10750 struct_ser.end()
10751 }
10752}
10753impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
10754 #[allow(deprecated)]
10755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10756 where
10757 D: serde::Deserializer<'de>,
10758 {
10759 const FIELDS: &[&str] = &[
10760 ];
10761
10762 #[allow(clippy::enum_variant_names)]
10763 enum GeneratedField {
10764 }
10765 impl<'de> serde::Deserialize<'de> for GeneratedField {
10766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10767 where
10768 D: serde::Deserializer<'de>,
10769 {
10770 struct GeneratedVisitor;
10771
10772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10773 type Value = GeneratedField;
10774
10775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10776 write!(formatter, "expected one of: {:?}", &FIELDS)
10777 }
10778
10779 #[allow(unused_variables)]
10780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10781 where
10782 E: serde::de::Error,
10783 {
10784 Err(serde::de::Error::unknown_field(value, FIELDS))
10785 }
10786 }
10787 deserializer.deserialize_identifier(GeneratedVisitor)
10788 }
10789 }
10790 struct GeneratedVisitor;
10791 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10792 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
10793
10794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10795 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
10796 }
10797
10798 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
10799 where
10800 V: serde::de::MapAccess<'de>,
10801 {
10802 while map_.next_key::<GeneratedField>()?.is_some() {
10803 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10804 }
10805 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
10806 })
10807 }
10808 }
10809 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
10810 }
10811}
10812impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
10813 #[allow(deprecated)]
10814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10815 where
10816 S: serde::Serializer,
10817 {
10818 use serde::ser::SerializeStruct;
10819 let mut len = 0;
10820 if self.summary.is_some() {
10821 len += 1;
10822 }
10823 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
10824 if let Some(v) = self.summary.as_ref() {
10825 struct_ser.serialize_field("summary", v)?;
10826 }
10827 struct_ser.end()
10828 }
10829}
10830impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
10831 #[allow(deprecated)]
10832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10833 where
10834 D: serde::Deserializer<'de>,
10835 {
10836 const FIELDS: &[&str] = &[
10837 "summary",
10838 ];
10839
10840 #[allow(clippy::enum_variant_names)]
10841 enum GeneratedField {
10842 Summary,
10843 }
10844 impl<'de> serde::Deserialize<'de> for GeneratedField {
10845 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10846 where
10847 D: serde::Deserializer<'de>,
10848 {
10849 struct GeneratedVisitor;
10850
10851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10852 type Value = GeneratedField;
10853
10854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10855 write!(formatter, "expected one of: {:?}", &FIELDS)
10856 }
10857
10858 #[allow(unused_variables)]
10859 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10860 where
10861 E: serde::de::Error,
10862 {
10863 match value {
10864 "summary" => Ok(GeneratedField::Summary),
10865 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10866 }
10867 }
10868 }
10869 deserializer.deserialize_identifier(GeneratedVisitor)
10870 }
10871 }
10872 struct GeneratedVisitor;
10873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10874 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
10875
10876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10877 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
10878 }
10879
10880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
10881 where
10882 V: serde::de::MapAccess<'de>,
10883 {
10884 let mut summary__ = None;
10885 while let Some(k) = map_.next_key()? {
10886 match k {
10887 GeneratedField::Summary => {
10888 if summary__.is_some() {
10889 return Err(serde::de::Error::duplicate_field("summary"));
10890 }
10891 summary__ = map_.next_value()?;
10892 }
10893 }
10894 }
10895 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
10896 summary: summary__,
10897 })
10898 }
10899 }
10900 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
10901 }
10902}
10903impl serde::Serialize for RiseCtlListCompactionGroupRequest {
10904 #[allow(deprecated)]
10905 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10906 where
10907 S: serde::Serializer,
10908 {
10909 use serde::ser::SerializeStruct;
10910 let len = 0;
10911 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
10912 struct_ser.end()
10913 }
10914}
10915impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
10916 #[allow(deprecated)]
10917 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10918 where
10919 D: serde::Deserializer<'de>,
10920 {
10921 const FIELDS: &[&str] = &[
10922 ];
10923
10924 #[allow(clippy::enum_variant_names)]
10925 enum GeneratedField {
10926 }
10927 impl<'de> serde::Deserialize<'de> for GeneratedField {
10928 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10929 where
10930 D: serde::Deserializer<'de>,
10931 {
10932 struct GeneratedVisitor;
10933
10934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10935 type Value = GeneratedField;
10936
10937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10938 write!(formatter, "expected one of: {:?}", &FIELDS)
10939 }
10940
10941 #[allow(unused_variables)]
10942 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10943 where
10944 E: serde::de::Error,
10945 {
10946 Err(serde::de::Error::unknown_field(value, FIELDS))
10947 }
10948 }
10949 deserializer.deserialize_identifier(GeneratedVisitor)
10950 }
10951 }
10952 struct GeneratedVisitor;
10953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10954 type Value = RiseCtlListCompactionGroupRequest;
10955
10956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10957 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
10958 }
10959
10960 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
10961 where
10962 V: serde::de::MapAccess<'de>,
10963 {
10964 while map_.next_key::<GeneratedField>()?.is_some() {
10965 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10966 }
10967 Ok(RiseCtlListCompactionGroupRequest {
10968 })
10969 }
10970 }
10971 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
10972 }
10973}
10974impl serde::Serialize for RiseCtlListCompactionGroupResponse {
10975 #[allow(deprecated)]
10976 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10977 where
10978 S: serde::Serializer,
10979 {
10980 use serde::ser::SerializeStruct;
10981 let mut len = 0;
10982 if self.status.is_some() {
10983 len += 1;
10984 }
10985 if !self.compaction_groups.is_empty() {
10986 len += 1;
10987 }
10988 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
10989 if let Some(v) = self.status.as_ref() {
10990 struct_ser.serialize_field("status", v)?;
10991 }
10992 if !self.compaction_groups.is_empty() {
10993 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
10994 }
10995 struct_ser.end()
10996 }
10997}
10998impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
10999 #[allow(deprecated)]
11000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11001 where
11002 D: serde::Deserializer<'de>,
11003 {
11004 const FIELDS: &[&str] = &[
11005 "status",
11006 "compaction_groups",
11007 "compactionGroups",
11008 ];
11009
11010 #[allow(clippy::enum_variant_names)]
11011 enum GeneratedField {
11012 Status,
11013 CompactionGroups,
11014 }
11015 impl<'de> serde::Deserialize<'de> for GeneratedField {
11016 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11017 where
11018 D: serde::Deserializer<'de>,
11019 {
11020 struct GeneratedVisitor;
11021
11022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11023 type Value = GeneratedField;
11024
11025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11026 write!(formatter, "expected one of: {:?}", &FIELDS)
11027 }
11028
11029 #[allow(unused_variables)]
11030 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11031 where
11032 E: serde::de::Error,
11033 {
11034 match value {
11035 "status" => Ok(GeneratedField::Status),
11036 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
11037 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11038 }
11039 }
11040 }
11041 deserializer.deserialize_identifier(GeneratedVisitor)
11042 }
11043 }
11044 struct GeneratedVisitor;
11045 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11046 type Value = RiseCtlListCompactionGroupResponse;
11047
11048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11049 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
11050 }
11051
11052 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
11053 where
11054 V: serde::de::MapAccess<'de>,
11055 {
11056 let mut status__ = None;
11057 let mut compaction_groups__ = None;
11058 while let Some(k) = map_.next_key()? {
11059 match k {
11060 GeneratedField::Status => {
11061 if status__.is_some() {
11062 return Err(serde::de::Error::duplicate_field("status"));
11063 }
11064 status__ = map_.next_value()?;
11065 }
11066 GeneratedField::CompactionGroups => {
11067 if compaction_groups__.is_some() {
11068 return Err(serde::de::Error::duplicate_field("compactionGroups"));
11069 }
11070 compaction_groups__ = Some(map_.next_value()?);
11071 }
11072 }
11073 }
11074 Ok(RiseCtlListCompactionGroupResponse {
11075 status: status__,
11076 compaction_groups: compaction_groups__.unwrap_or_default(),
11077 })
11078 }
11079 }
11080 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
11081 }
11082}
11083impl serde::Serialize for RiseCtlListCompactionStatusRequest {
11084 #[allow(deprecated)]
11085 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11086 where
11087 S: serde::Serializer,
11088 {
11089 use serde::ser::SerializeStruct;
11090 let len = 0;
11091 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
11092 struct_ser.end()
11093 }
11094}
11095impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
11096 #[allow(deprecated)]
11097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11098 where
11099 D: serde::Deserializer<'de>,
11100 {
11101 const FIELDS: &[&str] = &[
11102 ];
11103
11104 #[allow(clippy::enum_variant_names)]
11105 enum GeneratedField {
11106 }
11107 impl<'de> serde::Deserialize<'de> for GeneratedField {
11108 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11109 where
11110 D: serde::Deserializer<'de>,
11111 {
11112 struct GeneratedVisitor;
11113
11114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11115 type Value = GeneratedField;
11116
11117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11118 write!(formatter, "expected one of: {:?}", &FIELDS)
11119 }
11120
11121 #[allow(unused_variables)]
11122 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11123 where
11124 E: serde::de::Error,
11125 {
11126 Err(serde::de::Error::unknown_field(value, FIELDS))
11127 }
11128 }
11129 deserializer.deserialize_identifier(GeneratedVisitor)
11130 }
11131 }
11132 struct GeneratedVisitor;
11133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11134 type Value = RiseCtlListCompactionStatusRequest;
11135
11136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11137 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
11138 }
11139
11140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
11141 where
11142 V: serde::de::MapAccess<'de>,
11143 {
11144 while map_.next_key::<GeneratedField>()?.is_some() {
11145 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11146 }
11147 Ok(RiseCtlListCompactionStatusRequest {
11148 })
11149 }
11150 }
11151 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
11152 }
11153}
11154impl serde::Serialize for RiseCtlListCompactionStatusResponse {
11155 #[allow(deprecated)]
11156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11157 where
11158 S: serde::Serializer,
11159 {
11160 use serde::ser::SerializeStruct;
11161 let mut len = 0;
11162 if !self.compaction_statuses.is_empty() {
11163 len += 1;
11164 }
11165 if !self.task_assignment.is_empty() {
11166 len += 1;
11167 }
11168 if !self.task_progress.is_empty() {
11169 len += 1;
11170 }
11171 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
11172 if !self.compaction_statuses.is_empty() {
11173 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
11174 }
11175 if !self.task_assignment.is_empty() {
11176 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
11177 }
11178 if !self.task_progress.is_empty() {
11179 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
11180 }
11181 struct_ser.end()
11182 }
11183}
11184impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
11185 #[allow(deprecated)]
11186 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11187 where
11188 D: serde::Deserializer<'de>,
11189 {
11190 const FIELDS: &[&str] = &[
11191 "compaction_statuses",
11192 "compactionStatuses",
11193 "task_assignment",
11194 "taskAssignment",
11195 "task_progress",
11196 "taskProgress",
11197 ];
11198
11199 #[allow(clippy::enum_variant_names)]
11200 enum GeneratedField {
11201 CompactionStatuses,
11202 TaskAssignment,
11203 TaskProgress,
11204 }
11205 impl<'de> serde::Deserialize<'de> for GeneratedField {
11206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11207 where
11208 D: serde::Deserializer<'de>,
11209 {
11210 struct GeneratedVisitor;
11211
11212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11213 type Value = GeneratedField;
11214
11215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11216 write!(formatter, "expected one of: {:?}", &FIELDS)
11217 }
11218
11219 #[allow(unused_variables)]
11220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11221 where
11222 E: serde::de::Error,
11223 {
11224 match value {
11225 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
11226 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
11227 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
11228 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11229 }
11230 }
11231 }
11232 deserializer.deserialize_identifier(GeneratedVisitor)
11233 }
11234 }
11235 struct GeneratedVisitor;
11236 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11237 type Value = RiseCtlListCompactionStatusResponse;
11238
11239 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11240 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
11241 }
11242
11243 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
11244 where
11245 V: serde::de::MapAccess<'de>,
11246 {
11247 let mut compaction_statuses__ = None;
11248 let mut task_assignment__ = None;
11249 let mut task_progress__ = None;
11250 while let Some(k) = map_.next_key()? {
11251 match k {
11252 GeneratedField::CompactionStatuses => {
11253 if compaction_statuses__.is_some() {
11254 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
11255 }
11256 compaction_statuses__ = Some(map_.next_value()?);
11257 }
11258 GeneratedField::TaskAssignment => {
11259 if task_assignment__.is_some() {
11260 return Err(serde::de::Error::duplicate_field("taskAssignment"));
11261 }
11262 task_assignment__ = Some(map_.next_value()?);
11263 }
11264 GeneratedField::TaskProgress => {
11265 if task_progress__.is_some() {
11266 return Err(serde::de::Error::duplicate_field("taskProgress"));
11267 }
11268 task_progress__ = Some(map_.next_value()?);
11269 }
11270 }
11271 }
11272 Ok(RiseCtlListCompactionStatusResponse {
11273 compaction_statuses: compaction_statuses__.unwrap_or_default(),
11274 task_assignment: task_assignment__.unwrap_or_default(),
11275 task_progress: task_progress__.unwrap_or_default(),
11276 })
11277 }
11278 }
11279 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
11280 }
11281}
11282impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
11283 #[allow(deprecated)]
11284 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11285 where
11286 S: serde::Serializer,
11287 {
11288 use serde::ser::SerializeStruct;
11289 let len = 0;
11290 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
11291 struct_ser.end()
11292 }
11293}
11294impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
11295 #[allow(deprecated)]
11296 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11297 where
11298 D: serde::Deserializer<'de>,
11299 {
11300 const FIELDS: &[&str] = &[
11301 ];
11302
11303 #[allow(clippy::enum_variant_names)]
11304 enum GeneratedField {
11305 }
11306 impl<'de> serde::Deserialize<'de> for GeneratedField {
11307 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11308 where
11309 D: serde::Deserializer<'de>,
11310 {
11311 struct GeneratedVisitor;
11312
11313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11314 type Value = GeneratedField;
11315
11316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11317 write!(formatter, "expected one of: {:?}", &FIELDS)
11318 }
11319
11320 #[allow(unused_variables)]
11321 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11322 where
11323 E: serde::de::Error,
11324 {
11325 Err(serde::de::Error::unknown_field(value, FIELDS))
11326 }
11327 }
11328 deserializer.deserialize_identifier(GeneratedVisitor)
11329 }
11330 }
11331 struct GeneratedVisitor;
11332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11333 type Value = RiseCtlPauseVersionCheckpointRequest;
11334
11335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11336 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
11337 }
11338
11339 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
11340 where
11341 V: serde::de::MapAccess<'de>,
11342 {
11343 while map_.next_key::<GeneratedField>()?.is_some() {
11344 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11345 }
11346 Ok(RiseCtlPauseVersionCheckpointRequest {
11347 })
11348 }
11349 }
11350 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11351 }
11352}
11353impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
11354 #[allow(deprecated)]
11355 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11356 where
11357 S: serde::Serializer,
11358 {
11359 use serde::ser::SerializeStruct;
11360 let len = 0;
11361 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
11362 struct_ser.end()
11363 }
11364}
11365impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
11366 #[allow(deprecated)]
11367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11368 where
11369 D: serde::Deserializer<'de>,
11370 {
11371 const FIELDS: &[&str] = &[
11372 ];
11373
11374 #[allow(clippy::enum_variant_names)]
11375 enum GeneratedField {
11376 }
11377 impl<'de> serde::Deserialize<'de> for GeneratedField {
11378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11379 where
11380 D: serde::Deserializer<'de>,
11381 {
11382 struct GeneratedVisitor;
11383
11384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11385 type Value = GeneratedField;
11386
11387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11388 write!(formatter, "expected one of: {:?}", &FIELDS)
11389 }
11390
11391 #[allow(unused_variables)]
11392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11393 where
11394 E: serde::de::Error,
11395 {
11396 Err(serde::de::Error::unknown_field(value, FIELDS))
11397 }
11398 }
11399 deserializer.deserialize_identifier(GeneratedVisitor)
11400 }
11401 }
11402 struct GeneratedVisitor;
11403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11404 type Value = RiseCtlPauseVersionCheckpointResponse;
11405
11406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11407 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
11408 }
11409
11410 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
11411 where
11412 V: serde::de::MapAccess<'de>,
11413 {
11414 while map_.next_key::<GeneratedField>()?.is_some() {
11415 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11416 }
11417 Ok(RiseCtlPauseVersionCheckpointResponse {
11418 })
11419 }
11420 }
11421 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11422 }
11423}
11424impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
11425 #[allow(deprecated)]
11426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11427 where
11428 S: serde::Serializer,
11429 {
11430 use serde::ser::SerializeStruct;
11431 let len = 0;
11432 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
11433 struct_ser.end()
11434 }
11435}
11436impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
11437 #[allow(deprecated)]
11438 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11439 where
11440 D: serde::Deserializer<'de>,
11441 {
11442 const FIELDS: &[&str] = &[
11443 ];
11444
11445 #[allow(clippy::enum_variant_names)]
11446 enum GeneratedField {
11447 }
11448 impl<'de> serde::Deserialize<'de> for GeneratedField {
11449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11450 where
11451 D: serde::Deserializer<'de>,
11452 {
11453 struct GeneratedVisitor;
11454
11455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11456 type Value = GeneratedField;
11457
11458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11459 write!(formatter, "expected one of: {:?}", &FIELDS)
11460 }
11461
11462 #[allow(unused_variables)]
11463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11464 where
11465 E: serde::de::Error,
11466 {
11467 Err(serde::de::Error::unknown_field(value, FIELDS))
11468 }
11469 }
11470 deserializer.deserialize_identifier(GeneratedVisitor)
11471 }
11472 }
11473 struct GeneratedVisitor;
11474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11475 type Value = RiseCtlRebuildTableStatsRequest;
11476
11477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11478 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
11479 }
11480
11481 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
11482 where
11483 V: serde::de::MapAccess<'de>,
11484 {
11485 while map_.next_key::<GeneratedField>()?.is_some() {
11486 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11487 }
11488 Ok(RiseCtlRebuildTableStatsRequest {
11489 })
11490 }
11491 }
11492 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
11493 }
11494}
11495impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
11496 #[allow(deprecated)]
11497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11498 where
11499 S: serde::Serializer,
11500 {
11501 use serde::ser::SerializeStruct;
11502 let len = 0;
11503 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
11504 struct_ser.end()
11505 }
11506}
11507impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
11508 #[allow(deprecated)]
11509 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11510 where
11511 D: serde::Deserializer<'de>,
11512 {
11513 const FIELDS: &[&str] = &[
11514 ];
11515
11516 #[allow(clippy::enum_variant_names)]
11517 enum GeneratedField {
11518 }
11519 impl<'de> serde::Deserialize<'de> for GeneratedField {
11520 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11521 where
11522 D: serde::Deserializer<'de>,
11523 {
11524 struct GeneratedVisitor;
11525
11526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11527 type Value = GeneratedField;
11528
11529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11530 write!(formatter, "expected one of: {:?}", &FIELDS)
11531 }
11532
11533 #[allow(unused_variables)]
11534 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11535 where
11536 E: serde::de::Error,
11537 {
11538 Err(serde::de::Error::unknown_field(value, FIELDS))
11539 }
11540 }
11541 deserializer.deserialize_identifier(GeneratedVisitor)
11542 }
11543 }
11544 struct GeneratedVisitor;
11545 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11546 type Value = RiseCtlRebuildTableStatsResponse;
11547
11548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11549 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
11550 }
11551
11552 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
11553 where
11554 V: serde::de::MapAccess<'de>,
11555 {
11556 while map_.next_key::<GeneratedField>()?.is_some() {
11557 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11558 }
11559 Ok(RiseCtlRebuildTableStatsResponse {
11560 })
11561 }
11562 }
11563 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
11564 }
11565}
11566impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
11567 #[allow(deprecated)]
11568 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11569 where
11570 S: serde::Serializer,
11571 {
11572 use serde::ser::SerializeStruct;
11573 let len = 0;
11574 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
11575 struct_ser.end()
11576 }
11577}
11578impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
11579 #[allow(deprecated)]
11580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11581 where
11582 D: serde::Deserializer<'de>,
11583 {
11584 const FIELDS: &[&str] = &[
11585 ];
11586
11587 #[allow(clippy::enum_variant_names)]
11588 enum GeneratedField {
11589 }
11590 impl<'de> serde::Deserialize<'de> for GeneratedField {
11591 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11592 where
11593 D: serde::Deserializer<'de>,
11594 {
11595 struct GeneratedVisitor;
11596
11597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11598 type Value = GeneratedField;
11599
11600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11601 write!(formatter, "expected one of: {:?}", &FIELDS)
11602 }
11603
11604 #[allow(unused_variables)]
11605 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11606 where
11607 E: serde::de::Error,
11608 {
11609 Err(serde::de::Error::unknown_field(value, FIELDS))
11610 }
11611 }
11612 deserializer.deserialize_identifier(GeneratedVisitor)
11613 }
11614 }
11615 struct GeneratedVisitor;
11616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11617 type Value = RiseCtlResumeVersionCheckpointRequest;
11618
11619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11620 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
11621 }
11622
11623 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
11624 where
11625 V: serde::de::MapAccess<'de>,
11626 {
11627 while map_.next_key::<GeneratedField>()?.is_some() {
11628 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11629 }
11630 Ok(RiseCtlResumeVersionCheckpointRequest {
11631 })
11632 }
11633 }
11634 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11635 }
11636}
11637impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
11638 #[allow(deprecated)]
11639 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11640 where
11641 S: serde::Serializer,
11642 {
11643 use serde::ser::SerializeStruct;
11644 let len = 0;
11645 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
11646 struct_ser.end()
11647 }
11648}
11649impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
11650 #[allow(deprecated)]
11651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11652 where
11653 D: serde::Deserializer<'de>,
11654 {
11655 const FIELDS: &[&str] = &[
11656 ];
11657
11658 #[allow(clippy::enum_variant_names)]
11659 enum GeneratedField {
11660 }
11661 impl<'de> serde::Deserialize<'de> for GeneratedField {
11662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11663 where
11664 D: serde::Deserializer<'de>,
11665 {
11666 struct GeneratedVisitor;
11667
11668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11669 type Value = GeneratedField;
11670
11671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11672 write!(formatter, "expected one of: {:?}", &FIELDS)
11673 }
11674
11675 #[allow(unused_variables)]
11676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11677 where
11678 E: serde::de::Error,
11679 {
11680 Err(serde::de::Error::unknown_field(value, FIELDS))
11681 }
11682 }
11683 deserializer.deserialize_identifier(GeneratedVisitor)
11684 }
11685 }
11686 struct GeneratedVisitor;
11687 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11688 type Value = RiseCtlResumeVersionCheckpointResponse;
11689
11690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11691 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
11692 }
11693
11694 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
11695 where
11696 V: serde::de::MapAccess<'de>,
11697 {
11698 while map_.next_key::<GeneratedField>()?.is_some() {
11699 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11700 }
11701 Ok(RiseCtlResumeVersionCheckpointResponse {
11702 })
11703 }
11704 }
11705 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11706 }
11707}
11708impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
11709 #[allow(deprecated)]
11710 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11711 where
11712 S: serde::Serializer,
11713 {
11714 use serde::ser::SerializeStruct;
11715 let mut len = 0;
11716 if !self.compaction_group_ids.is_empty() {
11717 len += 1;
11718 }
11719 if !self.configs.is_empty() {
11720 len += 1;
11721 }
11722 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
11723 if !self.compaction_group_ids.is_empty() {
11724 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
11725 }
11726 if !self.configs.is_empty() {
11727 struct_ser.serialize_field("configs", &self.configs)?;
11728 }
11729 struct_ser.end()
11730 }
11731}
11732impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
11733 #[allow(deprecated)]
11734 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11735 where
11736 D: serde::Deserializer<'de>,
11737 {
11738 const FIELDS: &[&str] = &[
11739 "compaction_group_ids",
11740 "compactionGroupIds",
11741 "configs",
11742 ];
11743
11744 #[allow(clippy::enum_variant_names)]
11745 enum GeneratedField {
11746 CompactionGroupIds,
11747 Configs,
11748 }
11749 impl<'de> serde::Deserialize<'de> for GeneratedField {
11750 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11751 where
11752 D: serde::Deserializer<'de>,
11753 {
11754 struct GeneratedVisitor;
11755
11756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11757 type Value = GeneratedField;
11758
11759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11760 write!(formatter, "expected one of: {:?}", &FIELDS)
11761 }
11762
11763 #[allow(unused_variables)]
11764 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11765 where
11766 E: serde::de::Error,
11767 {
11768 match value {
11769 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
11770 "configs" => Ok(GeneratedField::Configs),
11771 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11772 }
11773 }
11774 }
11775 deserializer.deserialize_identifier(GeneratedVisitor)
11776 }
11777 }
11778 struct GeneratedVisitor;
11779 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11780 type Value = RiseCtlUpdateCompactionConfigRequest;
11781
11782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11783 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
11784 }
11785
11786 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
11787 where
11788 V: serde::de::MapAccess<'de>,
11789 {
11790 let mut compaction_group_ids__ = None;
11791 let mut configs__ = None;
11792 while let Some(k) = map_.next_key()? {
11793 match k {
11794 GeneratedField::CompactionGroupIds => {
11795 if compaction_group_ids__.is_some() {
11796 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
11797 }
11798 compaction_group_ids__ =
11799 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11800 .into_iter().map(|x| x.0).collect())
11801 ;
11802 }
11803 GeneratedField::Configs => {
11804 if configs__.is_some() {
11805 return Err(serde::de::Error::duplicate_field("configs"));
11806 }
11807 configs__ = Some(map_.next_value()?);
11808 }
11809 }
11810 }
11811 Ok(RiseCtlUpdateCompactionConfigRequest {
11812 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
11813 configs: configs__.unwrap_or_default(),
11814 })
11815 }
11816 }
11817 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
11818 }
11819}
11820impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11821 #[allow(deprecated)]
11822 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11823 where
11824 S: serde::Serializer,
11825 {
11826 use serde::ser::SerializeStruct;
11827 let mut len = 0;
11828 if self.level != 0 {
11829 len += 1;
11830 }
11831 if !self.compression_algorithm.is_empty() {
11832 len += 1;
11833 }
11834 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
11835 if self.level != 0 {
11836 struct_ser.serialize_field("level", &self.level)?;
11837 }
11838 if !self.compression_algorithm.is_empty() {
11839 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
11840 }
11841 struct_ser.end()
11842 }
11843}
11844impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11845 #[allow(deprecated)]
11846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11847 where
11848 D: serde::Deserializer<'de>,
11849 {
11850 const FIELDS: &[&str] = &[
11851 "level",
11852 "compression_algorithm",
11853 "compressionAlgorithm",
11854 ];
11855
11856 #[allow(clippy::enum_variant_names)]
11857 enum GeneratedField {
11858 Level,
11859 CompressionAlgorithm,
11860 }
11861 impl<'de> serde::Deserialize<'de> for GeneratedField {
11862 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11863 where
11864 D: serde::Deserializer<'de>,
11865 {
11866 struct GeneratedVisitor;
11867
11868 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11869 type Value = GeneratedField;
11870
11871 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11872 write!(formatter, "expected one of: {:?}", &FIELDS)
11873 }
11874
11875 #[allow(unused_variables)]
11876 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11877 where
11878 E: serde::de::Error,
11879 {
11880 match value {
11881 "level" => Ok(GeneratedField::Level),
11882 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
11883 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11884 }
11885 }
11886 }
11887 deserializer.deserialize_identifier(GeneratedVisitor)
11888 }
11889 }
11890 struct GeneratedVisitor;
11891 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11892 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
11893
11894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11895 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
11896 }
11897
11898 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
11899 where
11900 V: serde::de::MapAccess<'de>,
11901 {
11902 let mut level__ = None;
11903 let mut compression_algorithm__ = None;
11904 while let Some(k) = map_.next_key()? {
11905 match k {
11906 GeneratedField::Level => {
11907 if level__.is_some() {
11908 return Err(serde::de::Error::duplicate_field("level"));
11909 }
11910 level__ =
11911 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11912 ;
11913 }
11914 GeneratedField::CompressionAlgorithm => {
11915 if compression_algorithm__.is_some() {
11916 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
11917 }
11918 compression_algorithm__ = Some(map_.next_value()?);
11919 }
11920 }
11921 }
11922 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11923 level: level__.unwrap_or_default(),
11924 compression_algorithm: compression_algorithm__.unwrap_or_default(),
11925 })
11926 }
11927 }
11928 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
11929 }
11930}
11931impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
11932 #[allow(deprecated)]
11933 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11934 where
11935 S: serde::Serializer,
11936 {
11937 use serde::ser::SerializeStruct;
11938 let mut len = 0;
11939 if self.mutable_config.is_some() {
11940 len += 1;
11941 }
11942 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
11943 if let Some(v) = self.mutable_config.as_ref() {
11944 match v {
11945 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
11946 #[allow(clippy::needless_borrow)]
11947 #[allow(clippy::needless_borrows_for_generic_args)]
11948 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
11949 }
11950 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
11951 #[allow(clippy::needless_borrow)]
11952 #[allow(clippy::needless_borrows_for_generic_args)]
11953 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
11954 }
11955 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
11956 #[allow(clippy::needless_borrow)]
11957 #[allow(clippy::needless_borrows_for_generic_args)]
11958 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
11959 }
11960 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
11961 #[allow(clippy::needless_borrow)]
11962 #[allow(clippy::needless_borrows_for_generic_args)]
11963 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
11964 }
11965 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
11966 #[allow(clippy::needless_borrow)]
11967 #[allow(clippy::needless_borrows_for_generic_args)]
11968 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
11969 }
11970 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
11971 #[allow(clippy::needless_borrow)]
11972 #[allow(clippy::needless_borrows_for_generic_args)]
11973 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
11974 }
11975 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
11976 struct_ser.serialize_field("compactionFilterMask", v)?;
11977 }
11978 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
11979 struct_ser.serialize_field("maxSubCompaction", v)?;
11980 }
11981 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
11982 #[allow(clippy::needless_borrow)]
11983 #[allow(clippy::needless_borrows_for_generic_args)]
11984 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
11985 }
11986 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
11987 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
11988 }
11989 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
11990 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
11991 }
11992 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
11993 #[allow(clippy::needless_borrow)]
11994 #[allow(clippy::needless_borrows_for_generic_args)]
11995 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
11996 }
11997 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
11998 #[allow(clippy::needless_borrow)]
11999 #[allow(clippy::needless_borrows_for_generic_args)]
12000 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
12001 }
12002 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
12003 struct_ser.serialize_field("enableEmergencyPicker", v)?;
12004 }
12005 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
12006 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
12007 }
12008 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
12009 struct_ser.serialize_field("compressionAlgorithm", v)?;
12010 }
12011 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
12012 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
12013 }
12014 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
12015 #[allow(clippy::needless_borrow)]
12016 #[allow(clippy::needless_borrows_for_generic_args)]
12017 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
12018 }
12019 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
12020 struct_ser.serialize_field("splitWeightByVnode", v)?;
12021 }
12022 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
12023 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
12024 }
12025 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
12026 #[allow(clippy::needless_borrow)]
12027 #[allow(clippy::needless_borrows_for_generic_args)]
12028 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
12029 }
12030 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
12031 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
12032 }
12033 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
12034 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
12035 }
12036 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
12037 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
12038 }
12039 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
12040 #[allow(clippy::needless_borrow)]
12041 #[allow(clippy::needless_borrows_for_generic_args)]
12042 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
12043 }
12044 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
12045 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
12046 }
12047 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
12048 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
12049 }
12050 }
12051 }
12052 struct_ser.end()
12053 }
12054}
12055impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
12056 #[allow(deprecated)]
12057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12058 where
12059 D: serde::Deserializer<'de>,
12060 {
12061 const FIELDS: &[&str] = &[
12062 "max_bytes_for_level_base",
12063 "maxBytesForLevelBase",
12064 "max_bytes_for_level_multiplier",
12065 "maxBytesForLevelMultiplier",
12066 "max_compaction_bytes",
12067 "maxCompactionBytes",
12068 "sub_level_max_compaction_bytes",
12069 "subLevelMaxCompactionBytes",
12070 "level0_tier_compact_file_number",
12071 "level0TierCompactFileNumber",
12072 "target_file_size_base",
12073 "targetFileSizeBase",
12074 "compaction_filter_mask",
12075 "compactionFilterMask",
12076 "max_sub_compaction",
12077 "maxSubCompaction",
12078 "level0_stop_write_threshold_sub_level_number",
12079 "level0StopWriteThresholdSubLevelNumber",
12080 "level0_sub_level_compact_level_count",
12081 "level0SubLevelCompactLevelCount",
12082 "level0_overlapping_sub_level_compact_level_count",
12083 "level0OverlappingSubLevelCompactLevelCount",
12084 "max_space_reclaim_bytes",
12085 "maxSpaceReclaimBytes",
12086 "level0_max_compact_file_number",
12087 "level0MaxCompactFileNumber",
12088 "enable_emergency_picker",
12089 "enableEmergencyPicker",
12090 "tombstone_reclaim_ratio",
12091 "tombstoneReclaimRatio",
12092 "compression_algorithm",
12093 "compressionAlgorithm",
12094 "max_l0_compact_level_count",
12095 "maxL0CompactLevelCount",
12096 "sst_allowed_trivial_move_min_size",
12097 "sstAllowedTrivialMoveMinSize",
12098 "split_weight_by_vnode",
12099 "splitWeightByVnode",
12100 "disable_auto_group_scheduling",
12101 "disableAutoGroupScheduling",
12102 "max_overlapping_level_size",
12103 "maxOverlappingLevelSize",
12104 "emergency_level0_sst_file_count",
12105 "emergencyLevel0SstFileCount",
12106 "emergency_level0_sub_level_partition",
12107 "emergencyLevel0SubLevelPartition",
12108 "level0_stop_write_threshold_max_sst_count",
12109 "level0StopWriteThresholdMaxSstCount",
12110 "level0_stop_write_threshold_max_size",
12111 "level0StopWriteThresholdMaxSize",
12112 "sst_allowed_trivial_move_max_count",
12113 "sstAllowedTrivialMoveMaxCount",
12114 "enable_optimize_l0_interval_selection",
12115 "enableOptimizeL0IntervalSelection",
12116 ];
12117
12118 #[allow(clippy::enum_variant_names)]
12119 enum GeneratedField {
12120 MaxBytesForLevelBase,
12121 MaxBytesForLevelMultiplier,
12122 MaxCompactionBytes,
12123 SubLevelMaxCompactionBytes,
12124 Level0TierCompactFileNumber,
12125 TargetFileSizeBase,
12126 CompactionFilterMask,
12127 MaxSubCompaction,
12128 Level0StopWriteThresholdSubLevelNumber,
12129 Level0SubLevelCompactLevelCount,
12130 Level0OverlappingSubLevelCompactLevelCount,
12131 MaxSpaceReclaimBytes,
12132 Level0MaxCompactFileNumber,
12133 EnableEmergencyPicker,
12134 TombstoneReclaimRatio,
12135 CompressionAlgorithm,
12136 MaxL0CompactLevelCount,
12137 SstAllowedTrivialMoveMinSize,
12138 SplitWeightByVnode,
12139 DisableAutoGroupScheduling,
12140 MaxOverlappingLevelSize,
12141 EmergencyLevel0SstFileCount,
12142 EmergencyLevel0SubLevelPartition,
12143 Level0StopWriteThresholdMaxSstCount,
12144 Level0StopWriteThresholdMaxSize,
12145 SstAllowedTrivialMoveMaxCount,
12146 EnableOptimizeL0IntervalSelection,
12147 }
12148 impl<'de> serde::Deserialize<'de> for GeneratedField {
12149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12150 where
12151 D: serde::Deserializer<'de>,
12152 {
12153 struct GeneratedVisitor;
12154
12155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12156 type Value = GeneratedField;
12157
12158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12159 write!(formatter, "expected one of: {:?}", &FIELDS)
12160 }
12161
12162 #[allow(unused_variables)]
12163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12164 where
12165 E: serde::de::Error,
12166 {
12167 match value {
12168 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
12169 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
12170 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
12171 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
12172 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
12173 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
12174 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
12175 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
12176 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
12177 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
12178 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
12179 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
12180 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
12181 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
12182 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
12183 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12184 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
12185 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
12186 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
12187 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
12188 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
12189 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
12190 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
12191 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
12192 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
12193 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
12194 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
12195 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12196 }
12197 }
12198 }
12199 deserializer.deserialize_identifier(GeneratedVisitor)
12200 }
12201 }
12202 struct GeneratedVisitor;
12203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12204 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
12205
12206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12207 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
12208 }
12209
12210 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
12211 where
12212 V: serde::de::MapAccess<'de>,
12213 {
12214 let mut mutable_config__ = None;
12215 while let Some(k) = map_.next_key()? {
12216 match k {
12217 GeneratedField::MaxBytesForLevelBase => {
12218 if mutable_config__.is_some() {
12219 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
12220 }
12221 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));
12222 }
12223 GeneratedField::MaxBytesForLevelMultiplier => {
12224 if mutable_config__.is_some() {
12225 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
12226 }
12227 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));
12228 }
12229 GeneratedField::MaxCompactionBytes => {
12230 if mutable_config__.is_some() {
12231 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
12232 }
12233 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));
12234 }
12235 GeneratedField::SubLevelMaxCompactionBytes => {
12236 if mutable_config__.is_some() {
12237 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
12238 }
12239 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));
12240 }
12241 GeneratedField::Level0TierCompactFileNumber => {
12242 if mutable_config__.is_some() {
12243 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
12244 }
12245 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));
12246 }
12247 GeneratedField::TargetFileSizeBase => {
12248 if mutable_config__.is_some() {
12249 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
12250 }
12251 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));
12252 }
12253 GeneratedField::CompactionFilterMask => {
12254 if mutable_config__.is_some() {
12255 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
12256 }
12257 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));
12258 }
12259 GeneratedField::MaxSubCompaction => {
12260 if mutable_config__.is_some() {
12261 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
12262 }
12263 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));
12264 }
12265 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
12266 if mutable_config__.is_some() {
12267 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
12268 }
12269 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));
12270 }
12271 GeneratedField::Level0SubLevelCompactLevelCount => {
12272 if mutable_config__.is_some() {
12273 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
12274 }
12275 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));
12276 }
12277 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
12278 if mutable_config__.is_some() {
12279 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
12280 }
12281 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));
12282 }
12283 GeneratedField::MaxSpaceReclaimBytes => {
12284 if mutable_config__.is_some() {
12285 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
12286 }
12287 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));
12288 }
12289 GeneratedField::Level0MaxCompactFileNumber => {
12290 if mutable_config__.is_some() {
12291 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
12292 }
12293 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));
12294 }
12295 GeneratedField::EnableEmergencyPicker => {
12296 if mutable_config__.is_some() {
12297 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
12298 }
12299 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
12300 }
12301 GeneratedField::TombstoneReclaimRatio => {
12302 if mutable_config__.is_some() {
12303 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
12304 }
12305 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));
12306 }
12307 GeneratedField::CompressionAlgorithm => {
12308 if mutable_config__.is_some() {
12309 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12310 }
12311 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
12312;
12313 }
12314 GeneratedField::MaxL0CompactLevelCount => {
12315 if mutable_config__.is_some() {
12316 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
12317 }
12318 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));
12319 }
12320 GeneratedField::SstAllowedTrivialMoveMinSize => {
12321 if mutable_config__.is_some() {
12322 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
12323 }
12324 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));
12325 }
12326 GeneratedField::SplitWeightByVnode => {
12327 if mutable_config__.is_some() {
12328 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
12329 }
12330 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));
12331 }
12332 GeneratedField::DisableAutoGroupScheduling => {
12333 if mutable_config__.is_some() {
12334 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
12335 }
12336 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
12337 }
12338 GeneratedField::MaxOverlappingLevelSize => {
12339 if mutable_config__.is_some() {
12340 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
12341 }
12342 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));
12343 }
12344 GeneratedField::EmergencyLevel0SstFileCount => {
12345 if mutable_config__.is_some() {
12346 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
12347 }
12348 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));
12349 }
12350 GeneratedField::EmergencyLevel0SubLevelPartition => {
12351 if mutable_config__.is_some() {
12352 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
12353 }
12354 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));
12355 }
12356 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
12357 if mutable_config__.is_some() {
12358 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
12359 }
12360 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));
12361 }
12362 GeneratedField::Level0StopWriteThresholdMaxSize => {
12363 if mutable_config__.is_some() {
12364 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
12365 }
12366 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));
12367 }
12368 GeneratedField::SstAllowedTrivialMoveMaxCount => {
12369 if mutable_config__.is_some() {
12370 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
12371 }
12372 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));
12373 }
12374 GeneratedField::EnableOptimizeL0IntervalSelection => {
12375 if mutable_config__.is_some() {
12376 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
12377 }
12378 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
12379 }
12380 }
12381 }
12382 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
12383 mutable_config: mutable_config__,
12384 })
12385 }
12386 }
12387 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
12388 }
12389}
12390impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
12391 #[allow(deprecated)]
12392 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12393 where
12394 S: serde::Serializer,
12395 {
12396 use serde::ser::SerializeStruct;
12397 let mut len = 0;
12398 if self.status.is_some() {
12399 len += 1;
12400 }
12401 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
12402 if let Some(v) = self.status.as_ref() {
12403 struct_ser.serialize_field("status", v)?;
12404 }
12405 struct_ser.end()
12406 }
12407}
12408impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
12409 #[allow(deprecated)]
12410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12411 where
12412 D: serde::Deserializer<'de>,
12413 {
12414 const FIELDS: &[&str] = &[
12415 "status",
12416 ];
12417
12418 #[allow(clippy::enum_variant_names)]
12419 enum GeneratedField {
12420 Status,
12421 }
12422 impl<'de> serde::Deserialize<'de> for GeneratedField {
12423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12424 where
12425 D: serde::Deserializer<'de>,
12426 {
12427 struct GeneratedVisitor;
12428
12429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12430 type Value = GeneratedField;
12431
12432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12433 write!(formatter, "expected one of: {:?}", &FIELDS)
12434 }
12435
12436 #[allow(unused_variables)]
12437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12438 where
12439 E: serde::de::Error,
12440 {
12441 match value {
12442 "status" => Ok(GeneratedField::Status),
12443 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12444 }
12445 }
12446 }
12447 deserializer.deserialize_identifier(GeneratedVisitor)
12448 }
12449 }
12450 struct GeneratedVisitor;
12451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12452 type Value = RiseCtlUpdateCompactionConfigResponse;
12453
12454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12455 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
12456 }
12457
12458 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
12459 where
12460 V: serde::de::MapAccess<'de>,
12461 {
12462 let mut status__ = None;
12463 while let Some(k) = map_.next_key()? {
12464 match k {
12465 GeneratedField::Status => {
12466 if status__.is_some() {
12467 return Err(serde::de::Error::duplicate_field("status"));
12468 }
12469 status__ = map_.next_value()?;
12470 }
12471 }
12472 }
12473 Ok(RiseCtlUpdateCompactionConfigResponse {
12474 status: status__,
12475 })
12476 }
12477 }
12478 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
12479 }
12480}
12481impl serde::Serialize for SplitCompactionGroupRequest {
12482 #[allow(deprecated)]
12483 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12484 where
12485 S: serde::Serializer,
12486 {
12487 use serde::ser::SerializeStruct;
12488 let mut len = 0;
12489 if self.group_id != 0 {
12490 len += 1;
12491 }
12492 if !self.table_ids.is_empty() {
12493 len += 1;
12494 }
12495 if self.partition_vnode_count != 0 {
12496 len += 1;
12497 }
12498 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
12499 if self.group_id != 0 {
12500 #[allow(clippy::needless_borrow)]
12501 #[allow(clippy::needless_borrows_for_generic_args)]
12502 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
12503 }
12504 if !self.table_ids.is_empty() {
12505 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12506 }
12507 if self.partition_vnode_count != 0 {
12508 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
12509 }
12510 struct_ser.end()
12511 }
12512}
12513impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
12514 #[allow(deprecated)]
12515 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12516 where
12517 D: serde::Deserializer<'de>,
12518 {
12519 const FIELDS: &[&str] = &[
12520 "group_id",
12521 "groupId",
12522 "table_ids",
12523 "tableIds",
12524 "partition_vnode_count",
12525 "partitionVnodeCount",
12526 ];
12527
12528 #[allow(clippy::enum_variant_names)]
12529 enum GeneratedField {
12530 GroupId,
12531 TableIds,
12532 PartitionVnodeCount,
12533 }
12534 impl<'de> serde::Deserialize<'de> for GeneratedField {
12535 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12536 where
12537 D: serde::Deserializer<'de>,
12538 {
12539 struct GeneratedVisitor;
12540
12541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12542 type Value = GeneratedField;
12543
12544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12545 write!(formatter, "expected one of: {:?}", &FIELDS)
12546 }
12547
12548 #[allow(unused_variables)]
12549 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12550 where
12551 E: serde::de::Error,
12552 {
12553 match value {
12554 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
12555 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12556 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
12557 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12558 }
12559 }
12560 }
12561 deserializer.deserialize_identifier(GeneratedVisitor)
12562 }
12563 }
12564 struct GeneratedVisitor;
12565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12566 type Value = SplitCompactionGroupRequest;
12567
12568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12569 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
12570 }
12571
12572 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
12573 where
12574 V: serde::de::MapAccess<'de>,
12575 {
12576 let mut group_id__ = None;
12577 let mut table_ids__ = None;
12578 let mut partition_vnode_count__ = None;
12579 while let Some(k) = map_.next_key()? {
12580 match k {
12581 GeneratedField::GroupId => {
12582 if group_id__.is_some() {
12583 return Err(serde::de::Error::duplicate_field("groupId"));
12584 }
12585 group_id__ =
12586 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12587 ;
12588 }
12589 GeneratedField::TableIds => {
12590 if table_ids__.is_some() {
12591 return Err(serde::de::Error::duplicate_field("tableIds"));
12592 }
12593 table_ids__ =
12594 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12595 .into_iter().map(|x| x.0).collect())
12596 ;
12597 }
12598 GeneratedField::PartitionVnodeCount => {
12599 if partition_vnode_count__.is_some() {
12600 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
12601 }
12602 partition_vnode_count__ =
12603 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12604 ;
12605 }
12606 }
12607 }
12608 Ok(SplitCompactionGroupRequest {
12609 group_id: group_id__.unwrap_or_default(),
12610 table_ids: table_ids__.unwrap_or_default(),
12611 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
12612 })
12613 }
12614 }
12615 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
12616 }
12617}
12618impl serde::Serialize for SplitCompactionGroupResponse {
12619 #[allow(deprecated)]
12620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12621 where
12622 S: serde::Serializer,
12623 {
12624 use serde::ser::SerializeStruct;
12625 let mut len = 0;
12626 if self.new_group_id != 0 {
12627 len += 1;
12628 }
12629 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
12630 if self.new_group_id != 0 {
12631 #[allow(clippy::needless_borrow)]
12632 #[allow(clippy::needless_borrows_for_generic_args)]
12633 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
12634 }
12635 struct_ser.end()
12636 }
12637}
12638impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
12639 #[allow(deprecated)]
12640 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12641 where
12642 D: serde::Deserializer<'de>,
12643 {
12644 const FIELDS: &[&str] = &[
12645 "new_group_id",
12646 "newGroupId",
12647 ];
12648
12649 #[allow(clippy::enum_variant_names)]
12650 enum GeneratedField {
12651 NewGroupId,
12652 }
12653 impl<'de> serde::Deserialize<'de> for GeneratedField {
12654 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12655 where
12656 D: serde::Deserializer<'de>,
12657 {
12658 struct GeneratedVisitor;
12659
12660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12661 type Value = GeneratedField;
12662
12663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12664 write!(formatter, "expected one of: {:?}", &FIELDS)
12665 }
12666
12667 #[allow(unused_variables)]
12668 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12669 where
12670 E: serde::de::Error,
12671 {
12672 match value {
12673 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
12674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12675 }
12676 }
12677 }
12678 deserializer.deserialize_identifier(GeneratedVisitor)
12679 }
12680 }
12681 struct GeneratedVisitor;
12682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12683 type Value = SplitCompactionGroupResponse;
12684
12685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12686 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
12687 }
12688
12689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
12690 where
12691 V: serde::de::MapAccess<'de>,
12692 {
12693 let mut new_group_id__ = None;
12694 while let Some(k) = map_.next_key()? {
12695 match k {
12696 GeneratedField::NewGroupId => {
12697 if new_group_id__.is_some() {
12698 return Err(serde::de::Error::duplicate_field("newGroupId"));
12699 }
12700 new_group_id__ =
12701 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12702 ;
12703 }
12704 }
12705 }
12706 Ok(SplitCompactionGroupResponse {
12707 new_group_id: new_group_id__.unwrap_or_default(),
12708 })
12709 }
12710 }
12711 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
12712 }
12713}
12714impl serde::Serialize for SstableInfo {
12715 #[allow(deprecated)]
12716 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12717 where
12718 S: serde::Serializer,
12719 {
12720 use serde::ser::SerializeStruct;
12721 let mut len = 0;
12722 if self.object_id != 0 {
12723 len += 1;
12724 }
12725 if self.sst_id != 0 {
12726 len += 1;
12727 }
12728 if self.key_range.is_some() {
12729 len += 1;
12730 }
12731 if self.file_size != 0 {
12732 len += 1;
12733 }
12734 if !self.table_ids.is_empty() {
12735 len += 1;
12736 }
12737 if self.meta_offset != 0 {
12738 len += 1;
12739 }
12740 if self.stale_key_count != 0 {
12741 len += 1;
12742 }
12743 if self.total_key_count != 0 {
12744 len += 1;
12745 }
12746 if self.min_epoch != 0 {
12747 len += 1;
12748 }
12749 if self.max_epoch != 0 {
12750 len += 1;
12751 }
12752 if self.uncompressed_file_size != 0 {
12753 len += 1;
12754 }
12755 if self.range_tombstone_count != 0 {
12756 len += 1;
12757 }
12758 if self.bloom_filter_kind != 0 {
12759 len += 1;
12760 }
12761 if self.sst_size != 0 {
12762 len += 1;
12763 }
12764 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
12765 if self.object_id != 0 {
12766 #[allow(clippy::needless_borrow)]
12767 #[allow(clippy::needless_borrows_for_generic_args)]
12768 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
12769 }
12770 if self.sst_id != 0 {
12771 #[allow(clippy::needless_borrow)]
12772 #[allow(clippy::needless_borrows_for_generic_args)]
12773 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
12774 }
12775 if let Some(v) = self.key_range.as_ref() {
12776 struct_ser.serialize_field("keyRange", v)?;
12777 }
12778 if self.file_size != 0 {
12779 #[allow(clippy::needless_borrow)]
12780 #[allow(clippy::needless_borrows_for_generic_args)]
12781 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
12782 }
12783 if !self.table_ids.is_empty() {
12784 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12785 }
12786 if self.meta_offset != 0 {
12787 #[allow(clippy::needless_borrow)]
12788 #[allow(clippy::needless_borrows_for_generic_args)]
12789 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
12790 }
12791 if self.stale_key_count != 0 {
12792 #[allow(clippy::needless_borrow)]
12793 #[allow(clippy::needless_borrows_for_generic_args)]
12794 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
12795 }
12796 if self.total_key_count != 0 {
12797 #[allow(clippy::needless_borrow)]
12798 #[allow(clippy::needless_borrows_for_generic_args)]
12799 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
12800 }
12801 if self.min_epoch != 0 {
12802 #[allow(clippy::needless_borrow)]
12803 #[allow(clippy::needless_borrows_for_generic_args)]
12804 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
12805 }
12806 if self.max_epoch != 0 {
12807 #[allow(clippy::needless_borrow)]
12808 #[allow(clippy::needless_borrows_for_generic_args)]
12809 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
12810 }
12811 if self.uncompressed_file_size != 0 {
12812 #[allow(clippy::needless_borrow)]
12813 #[allow(clippy::needless_borrows_for_generic_args)]
12814 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
12815 }
12816 if self.range_tombstone_count != 0 {
12817 #[allow(clippy::needless_borrow)]
12818 #[allow(clippy::needless_borrows_for_generic_args)]
12819 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
12820 }
12821 if self.bloom_filter_kind != 0 {
12822 let v = BloomFilterType::try_from(self.bloom_filter_kind)
12823 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
12824 struct_ser.serialize_field("bloomFilterKind", &v)?;
12825 }
12826 if self.sst_size != 0 {
12827 #[allow(clippy::needless_borrow)]
12828 #[allow(clippy::needless_borrows_for_generic_args)]
12829 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
12830 }
12831 struct_ser.end()
12832 }
12833}
12834impl<'de> serde::Deserialize<'de> for SstableInfo {
12835 #[allow(deprecated)]
12836 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12837 where
12838 D: serde::Deserializer<'de>,
12839 {
12840 const FIELDS: &[&str] = &[
12841 "object_id",
12842 "objectId",
12843 "sst_id",
12844 "sstId",
12845 "key_range",
12846 "keyRange",
12847 "file_size",
12848 "fileSize",
12849 "table_ids",
12850 "tableIds",
12851 "meta_offset",
12852 "metaOffset",
12853 "stale_key_count",
12854 "staleKeyCount",
12855 "total_key_count",
12856 "totalKeyCount",
12857 "min_epoch",
12858 "minEpoch",
12859 "max_epoch",
12860 "maxEpoch",
12861 "uncompressed_file_size",
12862 "uncompressedFileSize",
12863 "range_tombstone_count",
12864 "rangeTombstoneCount",
12865 "bloom_filter_kind",
12866 "bloomFilterKind",
12867 "sst_size",
12868 "sstSize",
12869 ];
12870
12871 #[allow(clippy::enum_variant_names)]
12872 enum GeneratedField {
12873 ObjectId,
12874 SstId,
12875 KeyRange,
12876 FileSize,
12877 TableIds,
12878 MetaOffset,
12879 StaleKeyCount,
12880 TotalKeyCount,
12881 MinEpoch,
12882 MaxEpoch,
12883 UncompressedFileSize,
12884 RangeTombstoneCount,
12885 BloomFilterKind,
12886 SstSize,
12887 }
12888 impl<'de> serde::Deserialize<'de> for GeneratedField {
12889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12890 where
12891 D: serde::Deserializer<'de>,
12892 {
12893 struct GeneratedVisitor;
12894
12895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12896 type Value = GeneratedField;
12897
12898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12899 write!(formatter, "expected one of: {:?}", &FIELDS)
12900 }
12901
12902 #[allow(unused_variables)]
12903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12904 where
12905 E: serde::de::Error,
12906 {
12907 match value {
12908 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
12909 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
12910 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
12911 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
12912 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12913 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
12914 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
12915 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
12916 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
12917 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
12918 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
12919 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
12920 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
12921 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
12922 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12923 }
12924 }
12925 }
12926 deserializer.deserialize_identifier(GeneratedVisitor)
12927 }
12928 }
12929 struct GeneratedVisitor;
12930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12931 type Value = SstableInfo;
12932
12933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12934 formatter.write_str("struct hummock.SstableInfo")
12935 }
12936
12937 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
12938 where
12939 V: serde::de::MapAccess<'de>,
12940 {
12941 let mut object_id__ = None;
12942 let mut sst_id__ = None;
12943 let mut key_range__ = None;
12944 let mut file_size__ = None;
12945 let mut table_ids__ = None;
12946 let mut meta_offset__ = None;
12947 let mut stale_key_count__ = None;
12948 let mut total_key_count__ = None;
12949 let mut min_epoch__ = None;
12950 let mut max_epoch__ = None;
12951 let mut uncompressed_file_size__ = None;
12952 let mut range_tombstone_count__ = None;
12953 let mut bloom_filter_kind__ = None;
12954 let mut sst_size__ = None;
12955 while let Some(k) = map_.next_key()? {
12956 match k {
12957 GeneratedField::ObjectId => {
12958 if object_id__.is_some() {
12959 return Err(serde::de::Error::duplicate_field("objectId"));
12960 }
12961 object_id__ =
12962 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12963 ;
12964 }
12965 GeneratedField::SstId => {
12966 if sst_id__.is_some() {
12967 return Err(serde::de::Error::duplicate_field("sstId"));
12968 }
12969 sst_id__ =
12970 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12971 ;
12972 }
12973 GeneratedField::KeyRange => {
12974 if key_range__.is_some() {
12975 return Err(serde::de::Error::duplicate_field("keyRange"));
12976 }
12977 key_range__ = map_.next_value()?;
12978 }
12979 GeneratedField::FileSize => {
12980 if file_size__.is_some() {
12981 return Err(serde::de::Error::duplicate_field("fileSize"));
12982 }
12983 file_size__ =
12984 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12985 ;
12986 }
12987 GeneratedField::TableIds => {
12988 if table_ids__.is_some() {
12989 return Err(serde::de::Error::duplicate_field("tableIds"));
12990 }
12991 table_ids__ =
12992 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12993 .into_iter().map(|x| x.0).collect())
12994 ;
12995 }
12996 GeneratedField::MetaOffset => {
12997 if meta_offset__.is_some() {
12998 return Err(serde::de::Error::duplicate_field("metaOffset"));
12999 }
13000 meta_offset__ =
13001 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13002 ;
13003 }
13004 GeneratedField::StaleKeyCount => {
13005 if stale_key_count__.is_some() {
13006 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
13007 }
13008 stale_key_count__ =
13009 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13010 ;
13011 }
13012 GeneratedField::TotalKeyCount => {
13013 if total_key_count__.is_some() {
13014 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
13015 }
13016 total_key_count__ =
13017 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13018 ;
13019 }
13020 GeneratedField::MinEpoch => {
13021 if min_epoch__.is_some() {
13022 return Err(serde::de::Error::duplicate_field("minEpoch"));
13023 }
13024 min_epoch__ =
13025 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13026 ;
13027 }
13028 GeneratedField::MaxEpoch => {
13029 if max_epoch__.is_some() {
13030 return Err(serde::de::Error::duplicate_field("maxEpoch"));
13031 }
13032 max_epoch__ =
13033 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13034 ;
13035 }
13036 GeneratedField::UncompressedFileSize => {
13037 if uncompressed_file_size__.is_some() {
13038 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
13039 }
13040 uncompressed_file_size__ =
13041 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13042 ;
13043 }
13044 GeneratedField::RangeTombstoneCount => {
13045 if range_tombstone_count__.is_some() {
13046 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
13047 }
13048 range_tombstone_count__ =
13049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13050 ;
13051 }
13052 GeneratedField::BloomFilterKind => {
13053 if bloom_filter_kind__.is_some() {
13054 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
13055 }
13056 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
13057 }
13058 GeneratedField::SstSize => {
13059 if sst_size__.is_some() {
13060 return Err(serde::de::Error::duplicate_field("sstSize"));
13061 }
13062 sst_size__ =
13063 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13064 ;
13065 }
13066 }
13067 }
13068 Ok(SstableInfo {
13069 object_id: object_id__.unwrap_or_default(),
13070 sst_id: sst_id__.unwrap_or_default(),
13071 key_range: key_range__,
13072 file_size: file_size__.unwrap_or_default(),
13073 table_ids: table_ids__.unwrap_or_default(),
13074 meta_offset: meta_offset__.unwrap_or_default(),
13075 stale_key_count: stale_key_count__.unwrap_or_default(),
13076 total_key_count: total_key_count__.unwrap_or_default(),
13077 min_epoch: min_epoch__.unwrap_or_default(),
13078 max_epoch: max_epoch__.unwrap_or_default(),
13079 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
13080 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
13081 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
13082 sst_size: sst_size__.unwrap_or_default(),
13083 })
13084 }
13085 }
13086 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
13087 }
13088}
13089impl serde::Serialize for StateTableInfo {
13090 #[allow(deprecated)]
13091 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13092 where
13093 S: serde::Serializer,
13094 {
13095 use serde::ser::SerializeStruct;
13096 let mut len = 0;
13097 if self.committed_epoch != 0 {
13098 len += 1;
13099 }
13100 if self.compaction_group_id != 0 {
13101 len += 1;
13102 }
13103 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
13104 if self.committed_epoch != 0 {
13105 #[allow(clippy::needless_borrow)]
13106 #[allow(clippy::needless_borrows_for_generic_args)]
13107 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13108 }
13109 if self.compaction_group_id != 0 {
13110 #[allow(clippy::needless_borrow)]
13111 #[allow(clippy::needless_borrows_for_generic_args)]
13112 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13113 }
13114 struct_ser.end()
13115 }
13116}
13117impl<'de> serde::Deserialize<'de> for StateTableInfo {
13118 #[allow(deprecated)]
13119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13120 where
13121 D: serde::Deserializer<'de>,
13122 {
13123 const FIELDS: &[&str] = &[
13124 "committed_epoch",
13125 "committedEpoch",
13126 "compaction_group_id",
13127 "compactionGroupId",
13128 ];
13129
13130 #[allow(clippy::enum_variant_names)]
13131 enum GeneratedField {
13132 CommittedEpoch,
13133 CompactionGroupId,
13134 }
13135 impl<'de> serde::Deserialize<'de> for GeneratedField {
13136 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13137 where
13138 D: serde::Deserializer<'de>,
13139 {
13140 struct GeneratedVisitor;
13141
13142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13143 type Value = GeneratedField;
13144
13145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13146 write!(formatter, "expected one of: {:?}", &FIELDS)
13147 }
13148
13149 #[allow(unused_variables)]
13150 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13151 where
13152 E: serde::de::Error,
13153 {
13154 match value {
13155 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13156 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13157 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13158 }
13159 }
13160 }
13161 deserializer.deserialize_identifier(GeneratedVisitor)
13162 }
13163 }
13164 struct GeneratedVisitor;
13165 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13166 type Value = StateTableInfo;
13167
13168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13169 formatter.write_str("struct hummock.StateTableInfo")
13170 }
13171
13172 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
13173 where
13174 V: serde::de::MapAccess<'de>,
13175 {
13176 let mut committed_epoch__ = None;
13177 let mut compaction_group_id__ = None;
13178 while let Some(k) = map_.next_key()? {
13179 match k {
13180 GeneratedField::CommittedEpoch => {
13181 if committed_epoch__.is_some() {
13182 return Err(serde::de::Error::duplicate_field("committedEpoch"));
13183 }
13184 committed_epoch__ =
13185 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13186 ;
13187 }
13188 GeneratedField::CompactionGroupId => {
13189 if compaction_group_id__.is_some() {
13190 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
13191 }
13192 compaction_group_id__ =
13193 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13194 ;
13195 }
13196 }
13197 }
13198 Ok(StateTableInfo {
13199 committed_epoch: committed_epoch__.unwrap_or_default(),
13200 compaction_group_id: compaction_group_id__.unwrap_or_default(),
13201 })
13202 }
13203 }
13204 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
13205 }
13206}
13207impl serde::Serialize for StateTableInfoDelta {
13208 #[allow(deprecated)]
13209 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13210 where
13211 S: serde::Serializer,
13212 {
13213 use serde::ser::SerializeStruct;
13214 let mut len = 0;
13215 if self.committed_epoch != 0 {
13216 len += 1;
13217 }
13218 if self.compaction_group_id != 0 {
13219 len += 1;
13220 }
13221 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
13222 if self.committed_epoch != 0 {
13223 #[allow(clippy::needless_borrow)]
13224 #[allow(clippy::needless_borrows_for_generic_args)]
13225 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13226 }
13227 if self.compaction_group_id != 0 {
13228 #[allow(clippy::needless_borrow)]
13229 #[allow(clippy::needless_borrows_for_generic_args)]
13230 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13231 }
13232 struct_ser.end()
13233 }
13234}
13235impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
13236 #[allow(deprecated)]
13237 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13238 where
13239 D: serde::Deserializer<'de>,
13240 {
13241 const FIELDS: &[&str] = &[
13242 "committed_epoch",
13243 "committedEpoch",
13244 "compaction_group_id",
13245 "compactionGroupId",
13246 ];
13247
13248 #[allow(clippy::enum_variant_names)]
13249 enum GeneratedField {
13250 CommittedEpoch,
13251 CompactionGroupId,
13252 }
13253 impl<'de> serde::Deserialize<'de> for GeneratedField {
13254 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13255 where
13256 D: serde::Deserializer<'de>,
13257 {
13258 struct GeneratedVisitor;
13259
13260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13261 type Value = GeneratedField;
13262
13263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13264 write!(formatter, "expected one of: {:?}", &FIELDS)
13265 }
13266
13267 #[allow(unused_variables)]
13268 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13269 where
13270 E: serde::de::Error,
13271 {
13272 match value {
13273 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13274 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13275 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13276 }
13277 }
13278 }
13279 deserializer.deserialize_identifier(GeneratedVisitor)
13280 }
13281 }
13282 struct GeneratedVisitor;
13283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13284 type Value = StateTableInfoDelta;
13285
13286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13287 formatter.write_str("struct hummock.StateTableInfoDelta")
13288 }
13289
13290 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
13291 where
13292 V: serde::de::MapAccess<'de>,
13293 {
13294 let mut committed_epoch__ = None;
13295 let mut compaction_group_id__ = None;
13296 while let Some(k) = map_.next_key()? {
13297 match k {
13298 GeneratedField::CommittedEpoch => {
13299 if committed_epoch__.is_some() {
13300 return Err(serde::de::Error::duplicate_field("committedEpoch"));
13301 }
13302 committed_epoch__ =
13303 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13304 ;
13305 }
13306 GeneratedField::CompactionGroupId => {
13307 if compaction_group_id__.is_some() {
13308 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
13309 }
13310 compaction_group_id__ =
13311 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13312 ;
13313 }
13314 }
13315 }
13316 Ok(StateTableInfoDelta {
13317 committed_epoch: committed_epoch__.unwrap_or_default(),
13318 compaction_group_id: compaction_group_id__.unwrap_or_default(),
13319 })
13320 }
13321 }
13322 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
13323 }
13324}
13325impl serde::Serialize for SubscribeCompactionEventRequest {
13326 #[allow(deprecated)]
13327 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13328 where
13329 S: serde::Serializer,
13330 {
13331 use serde::ser::SerializeStruct;
13332 let mut len = 0;
13333 if self.create_at != 0 {
13334 len += 1;
13335 }
13336 if self.event.is_some() {
13337 len += 1;
13338 }
13339 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
13340 if self.create_at != 0 {
13341 #[allow(clippy::needless_borrow)]
13342 #[allow(clippy::needless_borrows_for_generic_args)]
13343 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
13344 }
13345 if let Some(v) = self.event.as_ref() {
13346 match v {
13347 subscribe_compaction_event_request::Event::Register(v) => {
13348 struct_ser.serialize_field("register", v)?;
13349 }
13350 subscribe_compaction_event_request::Event::PullTask(v) => {
13351 struct_ser.serialize_field("pullTask", v)?;
13352 }
13353 subscribe_compaction_event_request::Event::ReportTask(v) => {
13354 struct_ser.serialize_field("reportTask", v)?;
13355 }
13356 subscribe_compaction_event_request::Event::HeartBeat(v) => {
13357 struct_ser.serialize_field("heartBeat", v)?;
13358 }
13359 }
13360 }
13361 struct_ser.end()
13362 }
13363}
13364impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
13365 #[allow(deprecated)]
13366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13367 where
13368 D: serde::Deserializer<'de>,
13369 {
13370 const FIELDS: &[&str] = &[
13371 "create_at",
13372 "createAt",
13373 "register",
13374 "pull_task",
13375 "pullTask",
13376 "report_task",
13377 "reportTask",
13378 "heart_beat",
13379 "heartBeat",
13380 ];
13381
13382 #[allow(clippy::enum_variant_names)]
13383 enum GeneratedField {
13384 CreateAt,
13385 Register,
13386 PullTask,
13387 ReportTask,
13388 HeartBeat,
13389 }
13390 impl<'de> serde::Deserialize<'de> for GeneratedField {
13391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13392 where
13393 D: serde::Deserializer<'de>,
13394 {
13395 struct GeneratedVisitor;
13396
13397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13398 type Value = GeneratedField;
13399
13400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13401 write!(formatter, "expected one of: {:?}", &FIELDS)
13402 }
13403
13404 #[allow(unused_variables)]
13405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13406 where
13407 E: serde::de::Error,
13408 {
13409 match value {
13410 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
13411 "register" => Ok(GeneratedField::Register),
13412 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
13413 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
13414 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
13415 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13416 }
13417 }
13418 }
13419 deserializer.deserialize_identifier(GeneratedVisitor)
13420 }
13421 }
13422 struct GeneratedVisitor;
13423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13424 type Value = SubscribeCompactionEventRequest;
13425
13426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13427 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
13428 }
13429
13430 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
13431 where
13432 V: serde::de::MapAccess<'de>,
13433 {
13434 let mut create_at__ = None;
13435 let mut event__ = None;
13436 while let Some(k) = map_.next_key()? {
13437 match k {
13438 GeneratedField::CreateAt => {
13439 if create_at__.is_some() {
13440 return Err(serde::de::Error::duplicate_field("createAt"));
13441 }
13442 create_at__ =
13443 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13444 ;
13445 }
13446 GeneratedField::Register => {
13447 if event__.is_some() {
13448 return Err(serde::de::Error::duplicate_field("register"));
13449 }
13450 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
13451;
13452 }
13453 GeneratedField::PullTask => {
13454 if event__.is_some() {
13455 return Err(serde::de::Error::duplicate_field("pullTask"));
13456 }
13457 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
13458;
13459 }
13460 GeneratedField::ReportTask => {
13461 if event__.is_some() {
13462 return Err(serde::de::Error::duplicate_field("reportTask"));
13463 }
13464 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
13465;
13466 }
13467 GeneratedField::HeartBeat => {
13468 if event__.is_some() {
13469 return Err(serde::de::Error::duplicate_field("heartBeat"));
13470 }
13471 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
13472;
13473 }
13474 }
13475 }
13476 Ok(SubscribeCompactionEventRequest {
13477 create_at: create_at__.unwrap_or_default(),
13478 event: event__,
13479 })
13480 }
13481 }
13482 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
13483 }
13484}
13485impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
13486 #[allow(deprecated)]
13487 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13488 where
13489 S: serde::Serializer,
13490 {
13491 use serde::ser::SerializeStruct;
13492 let mut len = 0;
13493 if !self.progress.is_empty() {
13494 len += 1;
13495 }
13496 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
13497 if !self.progress.is_empty() {
13498 struct_ser.serialize_field("progress", &self.progress)?;
13499 }
13500 struct_ser.end()
13501 }
13502}
13503impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
13504 #[allow(deprecated)]
13505 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13506 where
13507 D: serde::Deserializer<'de>,
13508 {
13509 const FIELDS: &[&str] = &[
13510 "progress",
13511 ];
13512
13513 #[allow(clippy::enum_variant_names)]
13514 enum GeneratedField {
13515 Progress,
13516 }
13517 impl<'de> serde::Deserialize<'de> for GeneratedField {
13518 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13519 where
13520 D: serde::Deserializer<'de>,
13521 {
13522 struct GeneratedVisitor;
13523
13524 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13525 type Value = GeneratedField;
13526
13527 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13528 write!(formatter, "expected one of: {:?}", &FIELDS)
13529 }
13530
13531 #[allow(unused_variables)]
13532 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13533 where
13534 E: serde::de::Error,
13535 {
13536 match value {
13537 "progress" => Ok(GeneratedField::Progress),
13538 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13539 }
13540 }
13541 }
13542 deserializer.deserialize_identifier(GeneratedVisitor)
13543 }
13544 }
13545 struct GeneratedVisitor;
13546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13547 type Value = subscribe_compaction_event_request::HeartBeat;
13548
13549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13550 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
13551 }
13552
13553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
13554 where
13555 V: serde::de::MapAccess<'de>,
13556 {
13557 let mut progress__ = None;
13558 while let Some(k) = map_.next_key()? {
13559 match k {
13560 GeneratedField::Progress => {
13561 if progress__.is_some() {
13562 return Err(serde::de::Error::duplicate_field("progress"));
13563 }
13564 progress__ = Some(map_.next_value()?);
13565 }
13566 }
13567 }
13568 Ok(subscribe_compaction_event_request::HeartBeat {
13569 progress: progress__.unwrap_or_default(),
13570 })
13571 }
13572 }
13573 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
13574 }
13575}
13576impl serde::Serialize for subscribe_compaction_event_request::PullTask {
13577 #[allow(deprecated)]
13578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13579 where
13580 S: serde::Serializer,
13581 {
13582 use serde::ser::SerializeStruct;
13583 let mut len = 0;
13584 if self.pull_task_count != 0 {
13585 len += 1;
13586 }
13587 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
13588 if self.pull_task_count != 0 {
13589 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
13590 }
13591 struct_ser.end()
13592 }
13593}
13594impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
13595 #[allow(deprecated)]
13596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13597 where
13598 D: serde::Deserializer<'de>,
13599 {
13600 const FIELDS: &[&str] = &[
13601 "pull_task_count",
13602 "pullTaskCount",
13603 ];
13604
13605 #[allow(clippy::enum_variant_names)]
13606 enum GeneratedField {
13607 PullTaskCount,
13608 }
13609 impl<'de> serde::Deserialize<'de> for GeneratedField {
13610 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13611 where
13612 D: serde::Deserializer<'de>,
13613 {
13614 struct GeneratedVisitor;
13615
13616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13617 type Value = GeneratedField;
13618
13619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13620 write!(formatter, "expected one of: {:?}", &FIELDS)
13621 }
13622
13623 #[allow(unused_variables)]
13624 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13625 where
13626 E: serde::de::Error,
13627 {
13628 match value {
13629 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
13630 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13631 }
13632 }
13633 }
13634 deserializer.deserialize_identifier(GeneratedVisitor)
13635 }
13636 }
13637 struct GeneratedVisitor;
13638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13639 type Value = subscribe_compaction_event_request::PullTask;
13640
13641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13642 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
13643 }
13644
13645 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
13646 where
13647 V: serde::de::MapAccess<'de>,
13648 {
13649 let mut pull_task_count__ = None;
13650 while let Some(k) = map_.next_key()? {
13651 match k {
13652 GeneratedField::PullTaskCount => {
13653 if pull_task_count__.is_some() {
13654 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
13655 }
13656 pull_task_count__ =
13657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13658 ;
13659 }
13660 }
13661 }
13662 Ok(subscribe_compaction_event_request::PullTask {
13663 pull_task_count: pull_task_count__.unwrap_or_default(),
13664 })
13665 }
13666 }
13667 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
13668 }
13669}
13670impl serde::Serialize for subscribe_compaction_event_request::Register {
13671 #[allow(deprecated)]
13672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13673 where
13674 S: serde::Serializer,
13675 {
13676 use serde::ser::SerializeStruct;
13677 let mut len = 0;
13678 if self.context_id != 0 {
13679 len += 1;
13680 }
13681 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
13682 if self.context_id != 0 {
13683 struct_ser.serialize_field("contextId", &self.context_id)?;
13684 }
13685 struct_ser.end()
13686 }
13687}
13688impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
13689 #[allow(deprecated)]
13690 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13691 where
13692 D: serde::Deserializer<'de>,
13693 {
13694 const FIELDS: &[&str] = &[
13695 "context_id",
13696 "contextId",
13697 ];
13698
13699 #[allow(clippy::enum_variant_names)]
13700 enum GeneratedField {
13701 ContextId,
13702 }
13703 impl<'de> serde::Deserialize<'de> for GeneratedField {
13704 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13705 where
13706 D: serde::Deserializer<'de>,
13707 {
13708 struct GeneratedVisitor;
13709
13710 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13711 type Value = GeneratedField;
13712
13713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13714 write!(formatter, "expected one of: {:?}", &FIELDS)
13715 }
13716
13717 #[allow(unused_variables)]
13718 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13719 where
13720 E: serde::de::Error,
13721 {
13722 match value {
13723 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
13724 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13725 }
13726 }
13727 }
13728 deserializer.deserialize_identifier(GeneratedVisitor)
13729 }
13730 }
13731 struct GeneratedVisitor;
13732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13733 type Value = subscribe_compaction_event_request::Register;
13734
13735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13736 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
13737 }
13738
13739 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
13740 where
13741 V: serde::de::MapAccess<'de>,
13742 {
13743 let mut context_id__ = None;
13744 while let Some(k) = map_.next_key()? {
13745 match k {
13746 GeneratedField::ContextId => {
13747 if context_id__.is_some() {
13748 return Err(serde::de::Error::duplicate_field("contextId"));
13749 }
13750 context_id__ =
13751 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13752 ;
13753 }
13754 }
13755 }
13756 Ok(subscribe_compaction_event_request::Register {
13757 context_id: context_id__.unwrap_or_default(),
13758 })
13759 }
13760 }
13761 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
13762 }
13763}
13764impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
13765 #[allow(deprecated)]
13766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13767 where
13768 S: serde::Serializer,
13769 {
13770 use serde::ser::SerializeStruct;
13771 let mut len = 0;
13772 if !self.table_stats_change.is_empty() {
13773 len += 1;
13774 }
13775 if self.task_id != 0 {
13776 len += 1;
13777 }
13778 if self.task_status != 0 {
13779 len += 1;
13780 }
13781 if !self.sorted_output_ssts.is_empty() {
13782 len += 1;
13783 }
13784 if !self.object_timestamps.is_empty() {
13785 len += 1;
13786 }
13787 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
13788 if !self.table_stats_change.is_empty() {
13789 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
13790 }
13791 if self.task_id != 0 {
13792 #[allow(clippy::needless_borrow)]
13793 #[allow(clippy::needless_borrows_for_generic_args)]
13794 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
13795 }
13796 if self.task_status != 0 {
13797 let v = compact_task::TaskStatus::try_from(self.task_status)
13798 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
13799 struct_ser.serialize_field("taskStatus", &v)?;
13800 }
13801 if !self.sorted_output_ssts.is_empty() {
13802 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
13803 }
13804 if !self.object_timestamps.is_empty() {
13805 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
13806 .map(|(k, v)| (k, v.to_string())).collect();
13807 struct_ser.serialize_field("objectTimestamps", &v)?;
13808 }
13809 struct_ser.end()
13810 }
13811}
13812impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
13813 #[allow(deprecated)]
13814 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13815 where
13816 D: serde::Deserializer<'de>,
13817 {
13818 const FIELDS: &[&str] = &[
13819 "table_stats_change",
13820 "tableStatsChange",
13821 "task_id",
13822 "taskId",
13823 "task_status",
13824 "taskStatus",
13825 "sorted_output_ssts",
13826 "sortedOutputSsts",
13827 "object_timestamps",
13828 "objectTimestamps",
13829 ];
13830
13831 #[allow(clippy::enum_variant_names)]
13832 enum GeneratedField {
13833 TableStatsChange,
13834 TaskId,
13835 TaskStatus,
13836 SortedOutputSsts,
13837 ObjectTimestamps,
13838 }
13839 impl<'de> serde::Deserialize<'de> for GeneratedField {
13840 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13841 where
13842 D: serde::Deserializer<'de>,
13843 {
13844 struct GeneratedVisitor;
13845
13846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13847 type Value = GeneratedField;
13848
13849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13850 write!(formatter, "expected one of: {:?}", &FIELDS)
13851 }
13852
13853 #[allow(unused_variables)]
13854 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13855 where
13856 E: serde::de::Error,
13857 {
13858 match value {
13859 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
13860 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
13861 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
13862 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
13863 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
13864 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13865 }
13866 }
13867 }
13868 deserializer.deserialize_identifier(GeneratedVisitor)
13869 }
13870 }
13871 struct GeneratedVisitor;
13872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13873 type Value = subscribe_compaction_event_request::ReportTask;
13874
13875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13876 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
13877 }
13878
13879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
13880 where
13881 V: serde::de::MapAccess<'de>,
13882 {
13883 let mut table_stats_change__ = None;
13884 let mut task_id__ = None;
13885 let mut task_status__ = None;
13886 let mut sorted_output_ssts__ = None;
13887 let mut object_timestamps__ = None;
13888 while let Some(k) = map_.next_key()? {
13889 match k {
13890 GeneratedField::TableStatsChange => {
13891 if table_stats_change__.is_some() {
13892 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
13893 }
13894 table_stats_change__ = Some(
13895 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13896 .into_iter().map(|(k,v)| (k.0, v)).collect()
13897 );
13898 }
13899 GeneratedField::TaskId => {
13900 if task_id__.is_some() {
13901 return Err(serde::de::Error::duplicate_field("taskId"));
13902 }
13903 task_id__ =
13904 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13905 ;
13906 }
13907 GeneratedField::TaskStatus => {
13908 if task_status__.is_some() {
13909 return Err(serde::de::Error::duplicate_field("taskStatus"));
13910 }
13911 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
13912 }
13913 GeneratedField::SortedOutputSsts => {
13914 if sorted_output_ssts__.is_some() {
13915 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
13916 }
13917 sorted_output_ssts__ = Some(map_.next_value()?);
13918 }
13919 GeneratedField::ObjectTimestamps => {
13920 if object_timestamps__.is_some() {
13921 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
13922 }
13923 object_timestamps__ = Some(
13924 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
13925 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
13926 );
13927 }
13928 }
13929 }
13930 Ok(subscribe_compaction_event_request::ReportTask {
13931 table_stats_change: table_stats_change__.unwrap_or_default(),
13932 task_id: task_id__.unwrap_or_default(),
13933 task_status: task_status__.unwrap_or_default(),
13934 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
13935 object_timestamps: object_timestamps__.unwrap_or_default(),
13936 })
13937 }
13938 }
13939 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
13940 }
13941}
13942impl serde::Serialize for SubscribeCompactionEventResponse {
13943 #[allow(deprecated)]
13944 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13945 where
13946 S: serde::Serializer,
13947 {
13948 use serde::ser::SerializeStruct;
13949 let mut len = 0;
13950 if self.create_at != 0 {
13951 len += 1;
13952 }
13953 if self.event.is_some() {
13954 len += 1;
13955 }
13956 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
13957 if self.create_at != 0 {
13958 #[allow(clippy::needless_borrow)]
13959 #[allow(clippy::needless_borrows_for_generic_args)]
13960 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
13961 }
13962 if let Some(v) = self.event.as_ref() {
13963 match v {
13964 subscribe_compaction_event_response::Event::CompactTask(v) => {
13965 struct_ser.serialize_field("compactTask", v)?;
13966 }
13967 subscribe_compaction_event_response::Event::VacuumTask(v) => {
13968 struct_ser.serialize_field("vacuumTask", v)?;
13969 }
13970 subscribe_compaction_event_response::Event::FullScanTask(v) => {
13971 struct_ser.serialize_field("fullScanTask", v)?;
13972 }
13973 subscribe_compaction_event_response::Event::ValidationTask(v) => {
13974 struct_ser.serialize_field("validationTask", v)?;
13975 }
13976 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
13977 struct_ser.serialize_field("cancelCompactTask", v)?;
13978 }
13979 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
13980 struct_ser.serialize_field("pullTaskAck", v)?;
13981 }
13982 }
13983 }
13984 struct_ser.end()
13985 }
13986}
13987impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
13988 #[allow(deprecated)]
13989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13990 where
13991 D: serde::Deserializer<'de>,
13992 {
13993 const FIELDS: &[&str] = &[
13994 "create_at",
13995 "createAt",
13996 "compact_task",
13997 "compactTask",
13998 "vacuum_task",
13999 "vacuumTask",
14000 "full_scan_task",
14001 "fullScanTask",
14002 "validation_task",
14003 "validationTask",
14004 "cancel_compact_task",
14005 "cancelCompactTask",
14006 "pull_task_ack",
14007 "pullTaskAck",
14008 ];
14009
14010 #[allow(clippy::enum_variant_names)]
14011 enum GeneratedField {
14012 CreateAt,
14013 CompactTask,
14014 VacuumTask,
14015 FullScanTask,
14016 ValidationTask,
14017 CancelCompactTask,
14018 PullTaskAck,
14019 }
14020 impl<'de> serde::Deserialize<'de> for GeneratedField {
14021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14022 where
14023 D: serde::Deserializer<'de>,
14024 {
14025 struct GeneratedVisitor;
14026
14027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14028 type Value = GeneratedField;
14029
14030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14031 write!(formatter, "expected one of: {:?}", &FIELDS)
14032 }
14033
14034 #[allow(unused_variables)]
14035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14036 where
14037 E: serde::de::Error,
14038 {
14039 match value {
14040 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14041 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
14042 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
14043 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
14044 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
14045 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
14046 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
14047 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14048 }
14049 }
14050 }
14051 deserializer.deserialize_identifier(GeneratedVisitor)
14052 }
14053 }
14054 struct GeneratedVisitor;
14055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14056 type Value = SubscribeCompactionEventResponse;
14057
14058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14059 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
14060 }
14061
14062 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
14063 where
14064 V: serde::de::MapAccess<'de>,
14065 {
14066 let mut create_at__ = None;
14067 let mut event__ = None;
14068 while let Some(k) = map_.next_key()? {
14069 match k {
14070 GeneratedField::CreateAt => {
14071 if create_at__.is_some() {
14072 return Err(serde::de::Error::duplicate_field("createAt"));
14073 }
14074 create_at__ =
14075 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14076 ;
14077 }
14078 GeneratedField::CompactTask => {
14079 if event__.is_some() {
14080 return Err(serde::de::Error::duplicate_field("compactTask"));
14081 }
14082 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
14083;
14084 }
14085 GeneratedField::VacuumTask => {
14086 if event__.is_some() {
14087 return Err(serde::de::Error::duplicate_field("vacuumTask"));
14088 }
14089 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
14090;
14091 }
14092 GeneratedField::FullScanTask => {
14093 if event__.is_some() {
14094 return Err(serde::de::Error::duplicate_field("fullScanTask"));
14095 }
14096 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
14097;
14098 }
14099 GeneratedField::ValidationTask => {
14100 if event__.is_some() {
14101 return Err(serde::de::Error::duplicate_field("validationTask"));
14102 }
14103 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
14104;
14105 }
14106 GeneratedField::CancelCompactTask => {
14107 if event__.is_some() {
14108 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
14109 }
14110 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
14111;
14112 }
14113 GeneratedField::PullTaskAck => {
14114 if event__.is_some() {
14115 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
14116 }
14117 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
14118;
14119 }
14120 }
14121 }
14122 Ok(SubscribeCompactionEventResponse {
14123 create_at: create_at__.unwrap_or_default(),
14124 event: event__,
14125 })
14126 }
14127 }
14128 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
14129 }
14130}
14131impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
14132 #[allow(deprecated)]
14133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14134 where
14135 S: serde::Serializer,
14136 {
14137 use serde::ser::SerializeStruct;
14138 let len = 0;
14139 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
14140 struct_ser.end()
14141 }
14142}
14143impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
14144 #[allow(deprecated)]
14145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14146 where
14147 D: serde::Deserializer<'de>,
14148 {
14149 const FIELDS: &[&str] = &[
14150 ];
14151
14152 #[allow(clippy::enum_variant_names)]
14153 enum GeneratedField {
14154 }
14155 impl<'de> serde::Deserialize<'de> for GeneratedField {
14156 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14157 where
14158 D: serde::Deserializer<'de>,
14159 {
14160 struct GeneratedVisitor;
14161
14162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14163 type Value = GeneratedField;
14164
14165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14166 write!(formatter, "expected one of: {:?}", &FIELDS)
14167 }
14168
14169 #[allow(unused_variables)]
14170 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14171 where
14172 E: serde::de::Error,
14173 {
14174 Err(serde::de::Error::unknown_field(value, FIELDS))
14175 }
14176 }
14177 deserializer.deserialize_identifier(GeneratedVisitor)
14178 }
14179 }
14180 struct GeneratedVisitor;
14181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14182 type Value = subscribe_compaction_event_response::PullTaskAck;
14183
14184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14185 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
14186 }
14187
14188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
14189 where
14190 V: serde::de::MapAccess<'de>,
14191 {
14192 while map_.next_key::<GeneratedField>()?.is_some() {
14193 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14194 }
14195 Ok(subscribe_compaction_event_response::PullTaskAck {
14196 })
14197 }
14198 }
14199 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
14200 }
14201}
14202impl serde::Serialize for TableChangeLog {
14203 #[allow(deprecated)]
14204 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14205 where
14206 S: serde::Serializer,
14207 {
14208 use serde::ser::SerializeStruct;
14209 let mut len = 0;
14210 if !self.change_logs.is_empty() {
14211 len += 1;
14212 }
14213 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
14214 if !self.change_logs.is_empty() {
14215 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
14216 }
14217 struct_ser.end()
14218 }
14219}
14220impl<'de> serde::Deserialize<'de> for TableChangeLog {
14221 #[allow(deprecated)]
14222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14223 where
14224 D: serde::Deserializer<'de>,
14225 {
14226 const FIELDS: &[&str] = &[
14227 "change_logs",
14228 "changeLogs",
14229 ];
14230
14231 #[allow(clippy::enum_variant_names)]
14232 enum GeneratedField {
14233 ChangeLogs,
14234 }
14235 impl<'de> serde::Deserialize<'de> for GeneratedField {
14236 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14237 where
14238 D: serde::Deserializer<'de>,
14239 {
14240 struct GeneratedVisitor;
14241
14242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14243 type Value = GeneratedField;
14244
14245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14246 write!(formatter, "expected one of: {:?}", &FIELDS)
14247 }
14248
14249 #[allow(unused_variables)]
14250 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14251 where
14252 E: serde::de::Error,
14253 {
14254 match value {
14255 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
14256 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14257 }
14258 }
14259 }
14260 deserializer.deserialize_identifier(GeneratedVisitor)
14261 }
14262 }
14263 struct GeneratedVisitor;
14264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14265 type Value = TableChangeLog;
14266
14267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14268 formatter.write_str("struct hummock.TableChangeLog")
14269 }
14270
14271 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
14272 where
14273 V: serde::de::MapAccess<'de>,
14274 {
14275 let mut change_logs__ = None;
14276 while let Some(k) = map_.next_key()? {
14277 match k {
14278 GeneratedField::ChangeLogs => {
14279 if change_logs__.is_some() {
14280 return Err(serde::de::Error::duplicate_field("changeLogs"));
14281 }
14282 change_logs__ = Some(map_.next_value()?);
14283 }
14284 }
14285 }
14286 Ok(TableChangeLog {
14287 change_logs: change_logs__.unwrap_or_default(),
14288 })
14289 }
14290 }
14291 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
14292 }
14293}
14294impl serde::Serialize for TableOption {
14295 #[allow(deprecated)]
14296 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14297 where
14298 S: serde::Serializer,
14299 {
14300 use serde::ser::SerializeStruct;
14301 let mut len = 0;
14302 if self.retention_seconds.is_some() {
14303 len += 1;
14304 }
14305 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
14306 if let Some(v) = self.retention_seconds.as_ref() {
14307 struct_ser.serialize_field("retentionSeconds", v)?;
14308 }
14309 struct_ser.end()
14310 }
14311}
14312impl<'de> serde::Deserialize<'de> for TableOption {
14313 #[allow(deprecated)]
14314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14315 where
14316 D: serde::Deserializer<'de>,
14317 {
14318 const FIELDS: &[&str] = &[
14319 "retention_seconds",
14320 "retentionSeconds",
14321 ];
14322
14323 #[allow(clippy::enum_variant_names)]
14324 enum GeneratedField {
14325 RetentionSeconds,
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 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
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 = TableOption;
14358
14359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14360 formatter.write_str("struct hummock.TableOption")
14361 }
14362
14363 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
14364 where
14365 V: serde::de::MapAccess<'de>,
14366 {
14367 let mut retention_seconds__ = None;
14368 while let Some(k) = map_.next_key()? {
14369 match k {
14370 GeneratedField::RetentionSeconds => {
14371 if retention_seconds__.is_some() {
14372 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
14373 }
14374 retention_seconds__ =
14375 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14376 ;
14377 }
14378 }
14379 }
14380 Ok(TableOption {
14381 retention_seconds: retention_seconds__,
14382 })
14383 }
14384 }
14385 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
14386 }
14387}
14388impl serde::Serialize for TableSchema {
14389 #[allow(deprecated)]
14390 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14391 where
14392 S: serde::Serializer,
14393 {
14394 use serde::ser::SerializeStruct;
14395 let mut len = 0;
14396 if !self.column_ids.is_empty() {
14397 len += 1;
14398 }
14399 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
14400 if !self.column_ids.is_empty() {
14401 struct_ser.serialize_field("columnIds", &self.column_ids)?;
14402 }
14403 struct_ser.end()
14404 }
14405}
14406impl<'de> serde::Deserialize<'de> for TableSchema {
14407 #[allow(deprecated)]
14408 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14409 where
14410 D: serde::Deserializer<'de>,
14411 {
14412 const FIELDS: &[&str] = &[
14413 "column_ids",
14414 "columnIds",
14415 ];
14416
14417 #[allow(clippy::enum_variant_names)]
14418 enum GeneratedField {
14419 ColumnIds,
14420 }
14421 impl<'de> serde::Deserialize<'de> for GeneratedField {
14422 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14423 where
14424 D: serde::Deserializer<'de>,
14425 {
14426 struct GeneratedVisitor;
14427
14428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14429 type Value = GeneratedField;
14430
14431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14432 write!(formatter, "expected one of: {:?}", &FIELDS)
14433 }
14434
14435 #[allow(unused_variables)]
14436 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14437 where
14438 E: serde::de::Error,
14439 {
14440 match value {
14441 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
14442 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14443 }
14444 }
14445 }
14446 deserializer.deserialize_identifier(GeneratedVisitor)
14447 }
14448 }
14449 struct GeneratedVisitor;
14450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14451 type Value = TableSchema;
14452
14453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14454 formatter.write_str("struct hummock.TableSchema")
14455 }
14456
14457 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
14458 where
14459 V: serde::de::MapAccess<'de>,
14460 {
14461 let mut column_ids__ = None;
14462 while let Some(k) = map_.next_key()? {
14463 match k {
14464 GeneratedField::ColumnIds => {
14465 if column_ids__.is_some() {
14466 return Err(serde::de::Error::duplicate_field("columnIds"));
14467 }
14468 column_ids__ =
14469 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14470 .into_iter().map(|x| x.0).collect())
14471 ;
14472 }
14473 }
14474 }
14475 Ok(TableSchema {
14476 column_ids: column_ids__.unwrap_or_default(),
14477 })
14478 }
14479 }
14480 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
14481 }
14482}
14483impl serde::Serialize for TableStats {
14484 #[allow(deprecated)]
14485 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14486 where
14487 S: serde::Serializer,
14488 {
14489 use serde::ser::SerializeStruct;
14490 let mut len = 0;
14491 if self.total_key_size != 0 {
14492 len += 1;
14493 }
14494 if self.total_value_size != 0 {
14495 len += 1;
14496 }
14497 if self.total_key_count != 0 {
14498 len += 1;
14499 }
14500 if self.total_compressed_size != 0 {
14501 len += 1;
14502 }
14503 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
14504 if self.total_key_size != 0 {
14505 #[allow(clippy::needless_borrow)]
14506 #[allow(clippy::needless_borrows_for_generic_args)]
14507 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
14508 }
14509 if self.total_value_size != 0 {
14510 #[allow(clippy::needless_borrow)]
14511 #[allow(clippy::needless_borrows_for_generic_args)]
14512 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
14513 }
14514 if self.total_key_count != 0 {
14515 #[allow(clippy::needless_borrow)]
14516 #[allow(clippy::needless_borrows_for_generic_args)]
14517 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
14518 }
14519 if self.total_compressed_size != 0 {
14520 #[allow(clippy::needless_borrow)]
14521 #[allow(clippy::needless_borrows_for_generic_args)]
14522 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
14523 }
14524 struct_ser.end()
14525 }
14526}
14527impl<'de> serde::Deserialize<'de> for TableStats {
14528 #[allow(deprecated)]
14529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14530 where
14531 D: serde::Deserializer<'de>,
14532 {
14533 const FIELDS: &[&str] = &[
14534 "total_key_size",
14535 "totalKeySize",
14536 "total_value_size",
14537 "totalValueSize",
14538 "total_key_count",
14539 "totalKeyCount",
14540 "total_compressed_size",
14541 "totalCompressedSize",
14542 ];
14543
14544 #[allow(clippy::enum_variant_names)]
14545 enum GeneratedField {
14546 TotalKeySize,
14547 TotalValueSize,
14548 TotalKeyCount,
14549 TotalCompressedSize,
14550 }
14551 impl<'de> serde::Deserialize<'de> for GeneratedField {
14552 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14553 where
14554 D: serde::Deserializer<'de>,
14555 {
14556 struct GeneratedVisitor;
14557
14558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14559 type Value = GeneratedField;
14560
14561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14562 write!(formatter, "expected one of: {:?}", &FIELDS)
14563 }
14564
14565 #[allow(unused_variables)]
14566 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14567 where
14568 E: serde::de::Error,
14569 {
14570 match value {
14571 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
14572 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
14573 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
14574 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
14575 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14576 }
14577 }
14578 }
14579 deserializer.deserialize_identifier(GeneratedVisitor)
14580 }
14581 }
14582 struct GeneratedVisitor;
14583 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14584 type Value = TableStats;
14585
14586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14587 formatter.write_str("struct hummock.TableStats")
14588 }
14589
14590 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
14591 where
14592 V: serde::de::MapAccess<'de>,
14593 {
14594 let mut total_key_size__ = None;
14595 let mut total_value_size__ = None;
14596 let mut total_key_count__ = None;
14597 let mut total_compressed_size__ = None;
14598 while let Some(k) = map_.next_key()? {
14599 match k {
14600 GeneratedField::TotalKeySize => {
14601 if total_key_size__.is_some() {
14602 return Err(serde::de::Error::duplicate_field("totalKeySize"));
14603 }
14604 total_key_size__ =
14605 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14606 ;
14607 }
14608 GeneratedField::TotalValueSize => {
14609 if total_value_size__.is_some() {
14610 return Err(serde::de::Error::duplicate_field("totalValueSize"));
14611 }
14612 total_value_size__ =
14613 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14614 ;
14615 }
14616 GeneratedField::TotalKeyCount => {
14617 if total_key_count__.is_some() {
14618 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
14619 }
14620 total_key_count__ =
14621 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14622 ;
14623 }
14624 GeneratedField::TotalCompressedSize => {
14625 if total_compressed_size__.is_some() {
14626 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
14627 }
14628 total_compressed_size__ =
14629 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14630 ;
14631 }
14632 }
14633 }
14634 Ok(TableStats {
14635 total_key_size: total_key_size__.unwrap_or_default(),
14636 total_value_size: total_value_size__.unwrap_or_default(),
14637 total_key_count: total_key_count__.unwrap_or_default(),
14638 total_compressed_size: total_compressed_size__.unwrap_or_default(),
14639 })
14640 }
14641 }
14642 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
14643 }
14644}
14645impl serde::Serialize for TableWatermarks {
14646 #[allow(deprecated)]
14647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14648 where
14649 S: serde::Serializer,
14650 {
14651 use serde::ser::SerializeStruct;
14652 let mut len = 0;
14653 if !self.epoch_watermarks.is_empty() {
14654 len += 1;
14655 }
14656 if self.is_ascending {
14657 len += 1;
14658 }
14659 if self.is_non_pk_prefix {
14660 len += 1;
14661 }
14662 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
14663 if !self.epoch_watermarks.is_empty() {
14664 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
14665 }
14666 if self.is_ascending {
14667 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
14668 }
14669 if self.is_non_pk_prefix {
14670 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
14671 }
14672 struct_ser.end()
14673 }
14674}
14675impl<'de> serde::Deserialize<'de> for TableWatermarks {
14676 #[allow(deprecated)]
14677 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14678 where
14679 D: serde::Deserializer<'de>,
14680 {
14681 const FIELDS: &[&str] = &[
14682 "epoch_watermarks",
14683 "epochWatermarks",
14684 "is_ascending",
14685 "isAscending",
14686 "is_non_pk_prefix",
14687 "isNonPkPrefix",
14688 ];
14689
14690 #[allow(clippy::enum_variant_names)]
14691 enum GeneratedField {
14692 EpochWatermarks,
14693 IsAscending,
14694 IsNonPkPrefix,
14695 }
14696 impl<'de> serde::Deserialize<'de> for GeneratedField {
14697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14698 where
14699 D: serde::Deserializer<'de>,
14700 {
14701 struct GeneratedVisitor;
14702
14703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14704 type Value = GeneratedField;
14705
14706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14707 write!(formatter, "expected one of: {:?}", &FIELDS)
14708 }
14709
14710 #[allow(unused_variables)]
14711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14712 where
14713 E: serde::de::Error,
14714 {
14715 match value {
14716 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
14717 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
14718 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
14719 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14720 }
14721 }
14722 }
14723 deserializer.deserialize_identifier(GeneratedVisitor)
14724 }
14725 }
14726 struct GeneratedVisitor;
14727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14728 type Value = TableWatermarks;
14729
14730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14731 formatter.write_str("struct hummock.TableWatermarks")
14732 }
14733
14734 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
14735 where
14736 V: serde::de::MapAccess<'de>,
14737 {
14738 let mut epoch_watermarks__ = None;
14739 let mut is_ascending__ = None;
14740 let mut is_non_pk_prefix__ = None;
14741 while let Some(k) = map_.next_key()? {
14742 match k {
14743 GeneratedField::EpochWatermarks => {
14744 if epoch_watermarks__.is_some() {
14745 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
14746 }
14747 epoch_watermarks__ = Some(map_.next_value()?);
14748 }
14749 GeneratedField::IsAscending => {
14750 if is_ascending__.is_some() {
14751 return Err(serde::de::Error::duplicate_field("isAscending"));
14752 }
14753 is_ascending__ = Some(map_.next_value()?);
14754 }
14755 GeneratedField::IsNonPkPrefix => {
14756 if is_non_pk_prefix__.is_some() {
14757 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
14758 }
14759 is_non_pk_prefix__ = Some(map_.next_value()?);
14760 }
14761 }
14762 }
14763 Ok(TableWatermarks {
14764 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
14765 is_ascending: is_ascending__.unwrap_or_default(),
14766 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
14767 })
14768 }
14769 }
14770 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
14771 }
14772}
14773impl serde::Serialize for table_watermarks::EpochNewWatermarks {
14774 #[allow(deprecated)]
14775 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14776 where
14777 S: serde::Serializer,
14778 {
14779 use serde::ser::SerializeStruct;
14780 let mut len = 0;
14781 if !self.watermarks.is_empty() {
14782 len += 1;
14783 }
14784 if self.epoch != 0 {
14785 len += 1;
14786 }
14787 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
14788 if !self.watermarks.is_empty() {
14789 struct_ser.serialize_field("watermarks", &self.watermarks)?;
14790 }
14791 if self.epoch != 0 {
14792 #[allow(clippy::needless_borrow)]
14793 #[allow(clippy::needless_borrows_for_generic_args)]
14794 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
14795 }
14796 struct_ser.end()
14797 }
14798}
14799impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
14800 #[allow(deprecated)]
14801 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14802 where
14803 D: serde::Deserializer<'de>,
14804 {
14805 const FIELDS: &[&str] = &[
14806 "watermarks",
14807 "epoch",
14808 ];
14809
14810 #[allow(clippy::enum_variant_names)]
14811 enum GeneratedField {
14812 Watermarks,
14813 Epoch,
14814 }
14815 impl<'de> serde::Deserialize<'de> for GeneratedField {
14816 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14817 where
14818 D: serde::Deserializer<'de>,
14819 {
14820 struct GeneratedVisitor;
14821
14822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14823 type Value = GeneratedField;
14824
14825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14826 write!(formatter, "expected one of: {:?}", &FIELDS)
14827 }
14828
14829 #[allow(unused_variables)]
14830 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14831 where
14832 E: serde::de::Error,
14833 {
14834 match value {
14835 "watermarks" => Ok(GeneratedField::Watermarks),
14836 "epoch" => Ok(GeneratedField::Epoch),
14837 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14838 }
14839 }
14840 }
14841 deserializer.deserialize_identifier(GeneratedVisitor)
14842 }
14843 }
14844 struct GeneratedVisitor;
14845 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14846 type Value = table_watermarks::EpochNewWatermarks;
14847
14848 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14849 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
14850 }
14851
14852 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
14853 where
14854 V: serde::de::MapAccess<'de>,
14855 {
14856 let mut watermarks__ = None;
14857 let mut epoch__ = None;
14858 while let Some(k) = map_.next_key()? {
14859 match k {
14860 GeneratedField::Watermarks => {
14861 if watermarks__.is_some() {
14862 return Err(serde::de::Error::duplicate_field("watermarks"));
14863 }
14864 watermarks__ = Some(map_.next_value()?);
14865 }
14866 GeneratedField::Epoch => {
14867 if epoch__.is_some() {
14868 return Err(serde::de::Error::duplicate_field("epoch"));
14869 }
14870 epoch__ =
14871 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14872 ;
14873 }
14874 }
14875 }
14876 Ok(table_watermarks::EpochNewWatermarks {
14877 watermarks: watermarks__.unwrap_or_default(),
14878 epoch: epoch__.unwrap_or_default(),
14879 })
14880 }
14881 }
14882 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
14883 }
14884}
14885impl serde::Serialize for TriggerCompactionDeterministicRequest {
14886 #[allow(deprecated)]
14887 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14888 where
14889 S: serde::Serializer,
14890 {
14891 use serde::ser::SerializeStruct;
14892 let mut len = 0;
14893 if self.version_id != 0 {
14894 len += 1;
14895 }
14896 if !self.compaction_groups.is_empty() {
14897 len += 1;
14898 }
14899 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
14900 if self.version_id != 0 {
14901 #[allow(clippy::needless_borrow)]
14902 #[allow(clippy::needless_borrows_for_generic_args)]
14903 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
14904 }
14905 if !self.compaction_groups.is_empty() {
14906 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
14907 }
14908 struct_ser.end()
14909 }
14910}
14911impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
14912 #[allow(deprecated)]
14913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14914 where
14915 D: serde::Deserializer<'de>,
14916 {
14917 const FIELDS: &[&str] = &[
14918 "version_id",
14919 "versionId",
14920 "compaction_groups",
14921 "compactionGroups",
14922 ];
14923
14924 #[allow(clippy::enum_variant_names)]
14925 enum GeneratedField {
14926 VersionId,
14927 CompactionGroups,
14928 }
14929 impl<'de> serde::Deserialize<'de> for GeneratedField {
14930 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14931 where
14932 D: serde::Deserializer<'de>,
14933 {
14934 struct GeneratedVisitor;
14935
14936 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14937 type Value = GeneratedField;
14938
14939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14940 write!(formatter, "expected one of: {:?}", &FIELDS)
14941 }
14942
14943 #[allow(unused_variables)]
14944 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14945 where
14946 E: serde::de::Error,
14947 {
14948 match value {
14949 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
14950 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
14951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14952 }
14953 }
14954 }
14955 deserializer.deserialize_identifier(GeneratedVisitor)
14956 }
14957 }
14958 struct GeneratedVisitor;
14959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14960 type Value = TriggerCompactionDeterministicRequest;
14961
14962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14963 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
14964 }
14965
14966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
14967 where
14968 V: serde::de::MapAccess<'de>,
14969 {
14970 let mut version_id__ = None;
14971 let mut compaction_groups__ = None;
14972 while let Some(k) = map_.next_key()? {
14973 match k {
14974 GeneratedField::VersionId => {
14975 if version_id__.is_some() {
14976 return Err(serde::de::Error::duplicate_field("versionId"));
14977 }
14978 version_id__ =
14979 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14980 ;
14981 }
14982 GeneratedField::CompactionGroups => {
14983 if compaction_groups__.is_some() {
14984 return Err(serde::de::Error::duplicate_field("compactionGroups"));
14985 }
14986 compaction_groups__ =
14987 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14988 .into_iter().map(|x| x.0).collect())
14989 ;
14990 }
14991 }
14992 }
14993 Ok(TriggerCompactionDeterministicRequest {
14994 version_id: version_id__.unwrap_or_default(),
14995 compaction_groups: compaction_groups__.unwrap_or_default(),
14996 })
14997 }
14998 }
14999 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
15000 }
15001}
15002impl serde::Serialize for TriggerCompactionDeterministicResponse {
15003 #[allow(deprecated)]
15004 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15005 where
15006 S: serde::Serializer,
15007 {
15008 use serde::ser::SerializeStruct;
15009 let len = 0;
15010 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
15011 struct_ser.end()
15012 }
15013}
15014impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
15015 #[allow(deprecated)]
15016 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15017 where
15018 D: serde::Deserializer<'de>,
15019 {
15020 const FIELDS: &[&str] = &[
15021 ];
15022
15023 #[allow(clippy::enum_variant_names)]
15024 enum GeneratedField {
15025 }
15026 impl<'de> serde::Deserialize<'de> for GeneratedField {
15027 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15028 where
15029 D: serde::Deserializer<'de>,
15030 {
15031 struct GeneratedVisitor;
15032
15033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15034 type Value = GeneratedField;
15035
15036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15037 write!(formatter, "expected one of: {:?}", &FIELDS)
15038 }
15039
15040 #[allow(unused_variables)]
15041 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15042 where
15043 E: serde::de::Error,
15044 {
15045 Err(serde::de::Error::unknown_field(value, FIELDS))
15046 }
15047 }
15048 deserializer.deserialize_identifier(GeneratedVisitor)
15049 }
15050 }
15051 struct GeneratedVisitor;
15052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15053 type Value = TriggerCompactionDeterministicResponse;
15054
15055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15056 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
15057 }
15058
15059 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
15060 where
15061 V: serde::de::MapAccess<'de>,
15062 {
15063 while map_.next_key::<GeneratedField>()?.is_some() {
15064 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15065 }
15066 Ok(TriggerCompactionDeterministicResponse {
15067 })
15068 }
15069 }
15070 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
15071 }
15072}
15073impl serde::Serialize for TriggerFullGcRequest {
15074 #[allow(deprecated)]
15075 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15076 where
15077 S: serde::Serializer,
15078 {
15079 use serde::ser::SerializeStruct;
15080 let mut len = 0;
15081 if self.sst_retention_time_sec != 0 {
15082 len += 1;
15083 }
15084 if self.prefix.is_some() {
15085 len += 1;
15086 }
15087 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
15088 if self.sst_retention_time_sec != 0 {
15089 #[allow(clippy::needless_borrow)]
15090 #[allow(clippy::needless_borrows_for_generic_args)]
15091 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
15092 }
15093 if let Some(v) = self.prefix.as_ref() {
15094 struct_ser.serialize_field("prefix", v)?;
15095 }
15096 struct_ser.end()
15097 }
15098}
15099impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
15100 #[allow(deprecated)]
15101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15102 where
15103 D: serde::Deserializer<'de>,
15104 {
15105 const FIELDS: &[&str] = &[
15106 "sst_retention_time_sec",
15107 "sstRetentionTimeSec",
15108 "prefix",
15109 ];
15110
15111 #[allow(clippy::enum_variant_names)]
15112 enum GeneratedField {
15113 SstRetentionTimeSec,
15114 Prefix,
15115 }
15116 impl<'de> serde::Deserialize<'de> for GeneratedField {
15117 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15118 where
15119 D: serde::Deserializer<'de>,
15120 {
15121 struct GeneratedVisitor;
15122
15123 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15124 type Value = GeneratedField;
15125
15126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15127 write!(formatter, "expected one of: {:?}", &FIELDS)
15128 }
15129
15130 #[allow(unused_variables)]
15131 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15132 where
15133 E: serde::de::Error,
15134 {
15135 match value {
15136 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
15137 "prefix" => Ok(GeneratedField::Prefix),
15138 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15139 }
15140 }
15141 }
15142 deserializer.deserialize_identifier(GeneratedVisitor)
15143 }
15144 }
15145 struct GeneratedVisitor;
15146 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15147 type Value = TriggerFullGcRequest;
15148
15149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15150 formatter.write_str("struct hummock.TriggerFullGCRequest")
15151 }
15152
15153 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
15154 where
15155 V: serde::de::MapAccess<'de>,
15156 {
15157 let mut sst_retention_time_sec__ = None;
15158 let mut prefix__ = None;
15159 while let Some(k) = map_.next_key()? {
15160 match k {
15161 GeneratedField::SstRetentionTimeSec => {
15162 if sst_retention_time_sec__.is_some() {
15163 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
15164 }
15165 sst_retention_time_sec__ =
15166 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15167 ;
15168 }
15169 GeneratedField::Prefix => {
15170 if prefix__.is_some() {
15171 return Err(serde::de::Error::duplicate_field("prefix"));
15172 }
15173 prefix__ = map_.next_value()?;
15174 }
15175 }
15176 }
15177 Ok(TriggerFullGcRequest {
15178 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
15179 prefix: prefix__,
15180 })
15181 }
15182 }
15183 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
15184 }
15185}
15186impl serde::Serialize for TriggerFullGcResponse {
15187 #[allow(deprecated)]
15188 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15189 where
15190 S: serde::Serializer,
15191 {
15192 use serde::ser::SerializeStruct;
15193 let mut len = 0;
15194 if self.status.is_some() {
15195 len += 1;
15196 }
15197 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
15198 if let Some(v) = self.status.as_ref() {
15199 struct_ser.serialize_field("status", v)?;
15200 }
15201 struct_ser.end()
15202 }
15203}
15204impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
15205 #[allow(deprecated)]
15206 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15207 where
15208 D: serde::Deserializer<'de>,
15209 {
15210 const FIELDS: &[&str] = &[
15211 "status",
15212 ];
15213
15214 #[allow(clippy::enum_variant_names)]
15215 enum GeneratedField {
15216 Status,
15217 }
15218 impl<'de> serde::Deserialize<'de> for GeneratedField {
15219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15220 where
15221 D: serde::Deserializer<'de>,
15222 {
15223 struct GeneratedVisitor;
15224
15225 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15226 type Value = GeneratedField;
15227
15228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15229 write!(formatter, "expected one of: {:?}", &FIELDS)
15230 }
15231
15232 #[allow(unused_variables)]
15233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15234 where
15235 E: serde::de::Error,
15236 {
15237 match value {
15238 "status" => Ok(GeneratedField::Status),
15239 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15240 }
15241 }
15242 }
15243 deserializer.deserialize_identifier(GeneratedVisitor)
15244 }
15245 }
15246 struct GeneratedVisitor;
15247 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15248 type Value = TriggerFullGcResponse;
15249
15250 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15251 formatter.write_str("struct hummock.TriggerFullGCResponse")
15252 }
15253
15254 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
15255 where
15256 V: serde::de::MapAccess<'de>,
15257 {
15258 let mut status__ = None;
15259 while let Some(k) = map_.next_key()? {
15260 match k {
15261 GeneratedField::Status => {
15262 if status__.is_some() {
15263 return Err(serde::de::Error::duplicate_field("status"));
15264 }
15265 status__ = map_.next_value()?;
15266 }
15267 }
15268 }
15269 Ok(TriggerFullGcResponse {
15270 status: status__,
15271 })
15272 }
15273 }
15274 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
15275 }
15276}
15277impl serde::Serialize for TriggerManualCompactionRequest {
15278 #[allow(deprecated)]
15279 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15280 where
15281 S: serde::Serializer,
15282 {
15283 use serde::ser::SerializeStruct;
15284 let mut len = 0;
15285 if self.compaction_group_id != 0 {
15286 len += 1;
15287 }
15288 if self.key_range.is_some() {
15289 len += 1;
15290 }
15291 if self.table_id != 0 {
15292 len += 1;
15293 }
15294 if self.level != 0 {
15295 len += 1;
15296 }
15297 if !self.sst_ids.is_empty() {
15298 len += 1;
15299 }
15300 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
15301 if self.compaction_group_id != 0 {
15302 #[allow(clippy::needless_borrow)]
15303 #[allow(clippy::needless_borrows_for_generic_args)]
15304 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
15305 }
15306 if let Some(v) = self.key_range.as_ref() {
15307 struct_ser.serialize_field("keyRange", v)?;
15308 }
15309 if self.table_id != 0 {
15310 struct_ser.serialize_field("tableId", &self.table_id)?;
15311 }
15312 if self.level != 0 {
15313 struct_ser.serialize_field("level", &self.level)?;
15314 }
15315 if !self.sst_ids.is_empty() {
15316 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15317 }
15318 struct_ser.end()
15319 }
15320}
15321impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
15322 #[allow(deprecated)]
15323 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15324 where
15325 D: serde::Deserializer<'de>,
15326 {
15327 const FIELDS: &[&str] = &[
15328 "compaction_group_id",
15329 "compactionGroupId",
15330 "key_range",
15331 "keyRange",
15332 "table_id",
15333 "tableId",
15334 "level",
15335 "sst_ids",
15336 "sstIds",
15337 ];
15338
15339 #[allow(clippy::enum_variant_names)]
15340 enum GeneratedField {
15341 CompactionGroupId,
15342 KeyRange,
15343 TableId,
15344 Level,
15345 SstIds,
15346 }
15347 impl<'de> serde::Deserialize<'de> for GeneratedField {
15348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15349 where
15350 D: serde::Deserializer<'de>,
15351 {
15352 struct GeneratedVisitor;
15353
15354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15355 type Value = GeneratedField;
15356
15357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15358 write!(formatter, "expected one of: {:?}", &FIELDS)
15359 }
15360
15361 #[allow(unused_variables)]
15362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15363 where
15364 E: serde::de::Error,
15365 {
15366 match value {
15367 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
15368 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
15369 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15370 "level" => Ok(GeneratedField::Level),
15371 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
15372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15373 }
15374 }
15375 }
15376 deserializer.deserialize_identifier(GeneratedVisitor)
15377 }
15378 }
15379 struct GeneratedVisitor;
15380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15381 type Value = TriggerManualCompactionRequest;
15382
15383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15384 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
15385 }
15386
15387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
15388 where
15389 V: serde::de::MapAccess<'de>,
15390 {
15391 let mut compaction_group_id__ = None;
15392 let mut key_range__ = None;
15393 let mut table_id__ = None;
15394 let mut level__ = None;
15395 let mut sst_ids__ = None;
15396 while let Some(k) = map_.next_key()? {
15397 match k {
15398 GeneratedField::CompactionGroupId => {
15399 if compaction_group_id__.is_some() {
15400 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
15401 }
15402 compaction_group_id__ =
15403 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15404 ;
15405 }
15406 GeneratedField::KeyRange => {
15407 if key_range__.is_some() {
15408 return Err(serde::de::Error::duplicate_field("keyRange"));
15409 }
15410 key_range__ = map_.next_value()?;
15411 }
15412 GeneratedField::TableId => {
15413 if table_id__.is_some() {
15414 return Err(serde::de::Error::duplicate_field("tableId"));
15415 }
15416 table_id__ =
15417 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15418 ;
15419 }
15420 GeneratedField::Level => {
15421 if level__.is_some() {
15422 return Err(serde::de::Error::duplicate_field("level"));
15423 }
15424 level__ =
15425 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15426 ;
15427 }
15428 GeneratedField::SstIds => {
15429 if sst_ids__.is_some() {
15430 return Err(serde::de::Error::duplicate_field("sstIds"));
15431 }
15432 sst_ids__ =
15433 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15434 .into_iter().map(|x| x.0).collect())
15435 ;
15436 }
15437 }
15438 }
15439 Ok(TriggerManualCompactionRequest {
15440 compaction_group_id: compaction_group_id__.unwrap_or_default(),
15441 key_range: key_range__,
15442 table_id: table_id__.unwrap_or_default(),
15443 level: level__.unwrap_or_default(),
15444 sst_ids: sst_ids__.unwrap_or_default(),
15445 })
15446 }
15447 }
15448 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
15449 }
15450}
15451impl serde::Serialize for TriggerManualCompactionResponse {
15452 #[allow(deprecated)]
15453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15454 where
15455 S: serde::Serializer,
15456 {
15457 use serde::ser::SerializeStruct;
15458 let mut len = 0;
15459 if self.status.is_some() {
15460 len += 1;
15461 }
15462 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
15463 if let Some(v) = self.status.as_ref() {
15464 struct_ser.serialize_field("status", v)?;
15465 }
15466 struct_ser.end()
15467 }
15468}
15469impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
15470 #[allow(deprecated)]
15471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15472 where
15473 D: serde::Deserializer<'de>,
15474 {
15475 const FIELDS: &[&str] = &[
15476 "status",
15477 ];
15478
15479 #[allow(clippy::enum_variant_names)]
15480 enum GeneratedField {
15481 Status,
15482 }
15483 impl<'de> serde::Deserialize<'de> for GeneratedField {
15484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15485 where
15486 D: serde::Deserializer<'de>,
15487 {
15488 struct GeneratedVisitor;
15489
15490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15491 type Value = GeneratedField;
15492
15493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15494 write!(formatter, "expected one of: {:?}", &FIELDS)
15495 }
15496
15497 #[allow(unused_variables)]
15498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15499 where
15500 E: serde::de::Error,
15501 {
15502 match value {
15503 "status" => Ok(GeneratedField::Status),
15504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15505 }
15506 }
15507 }
15508 deserializer.deserialize_identifier(GeneratedVisitor)
15509 }
15510 }
15511 struct GeneratedVisitor;
15512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15513 type Value = TriggerManualCompactionResponse;
15514
15515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15516 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
15517 }
15518
15519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
15520 where
15521 V: serde::de::MapAccess<'de>,
15522 {
15523 let mut status__ = None;
15524 while let Some(k) = map_.next_key()? {
15525 match k {
15526 GeneratedField::Status => {
15527 if status__.is_some() {
15528 return Err(serde::de::Error::duplicate_field("status"));
15529 }
15530 status__ = map_.next_value()?;
15531 }
15532 }
15533 }
15534 Ok(TriggerManualCompactionResponse {
15535 status: status__,
15536 })
15537 }
15538 }
15539 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
15540 }
15541}
15542impl serde::Serialize for TruncateTables {
15543 #[allow(deprecated)]
15544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15545 where
15546 S: serde::Serializer,
15547 {
15548 use serde::ser::SerializeStruct;
15549 let mut len = 0;
15550 if !self.table_ids.is_empty() {
15551 len += 1;
15552 }
15553 let mut struct_ser = serializer.serialize_struct("hummock.TruncateTables", len)?;
15554 if !self.table_ids.is_empty() {
15555 struct_ser.serialize_field("tableIds", &self.table_ids)?;
15556 }
15557 struct_ser.end()
15558 }
15559}
15560impl<'de> serde::Deserialize<'de> for TruncateTables {
15561 #[allow(deprecated)]
15562 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15563 where
15564 D: serde::Deserializer<'de>,
15565 {
15566 const FIELDS: &[&str] = &[
15567 "table_ids",
15568 "tableIds",
15569 ];
15570
15571 #[allow(clippy::enum_variant_names)]
15572 enum GeneratedField {
15573 TableIds,
15574 }
15575 impl<'de> serde::Deserialize<'de> for GeneratedField {
15576 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15577 where
15578 D: serde::Deserializer<'de>,
15579 {
15580 struct GeneratedVisitor;
15581
15582 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15583 type Value = GeneratedField;
15584
15585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15586 write!(formatter, "expected one of: {:?}", &FIELDS)
15587 }
15588
15589 #[allow(unused_variables)]
15590 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15591 where
15592 E: serde::de::Error,
15593 {
15594 match value {
15595 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
15596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15597 }
15598 }
15599 }
15600 deserializer.deserialize_identifier(GeneratedVisitor)
15601 }
15602 }
15603 struct GeneratedVisitor;
15604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15605 type Value = TruncateTables;
15606
15607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15608 formatter.write_str("struct hummock.TruncateTables")
15609 }
15610
15611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TruncateTables, V::Error>
15612 where
15613 V: serde::de::MapAccess<'de>,
15614 {
15615 let mut table_ids__ = None;
15616 while let Some(k) = map_.next_key()? {
15617 match k {
15618 GeneratedField::TableIds => {
15619 if table_ids__.is_some() {
15620 return Err(serde::de::Error::duplicate_field("tableIds"));
15621 }
15622 table_ids__ =
15623 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15624 .into_iter().map(|x| x.0).collect())
15625 ;
15626 }
15627 }
15628 }
15629 Ok(TruncateTables {
15630 table_ids: table_ids__.unwrap_or_default(),
15631 })
15632 }
15633 }
15634 deserializer.deserialize_struct("hummock.TruncateTables", FIELDS, GeneratedVisitor)
15635 }
15636}
15637impl serde::Serialize for UnpinVersionBeforeRequest {
15638 #[allow(deprecated)]
15639 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15640 where
15641 S: serde::Serializer,
15642 {
15643 use serde::ser::SerializeStruct;
15644 let mut len = 0;
15645 if self.context_id != 0 {
15646 len += 1;
15647 }
15648 if self.unpin_version_before != 0 {
15649 len += 1;
15650 }
15651 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
15652 if self.context_id != 0 {
15653 struct_ser.serialize_field("contextId", &self.context_id)?;
15654 }
15655 if self.unpin_version_before != 0 {
15656 #[allow(clippy::needless_borrow)]
15657 #[allow(clippy::needless_borrows_for_generic_args)]
15658 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
15659 }
15660 struct_ser.end()
15661 }
15662}
15663impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
15664 #[allow(deprecated)]
15665 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15666 where
15667 D: serde::Deserializer<'de>,
15668 {
15669 const FIELDS: &[&str] = &[
15670 "context_id",
15671 "contextId",
15672 "unpin_version_before",
15673 "unpinVersionBefore",
15674 ];
15675
15676 #[allow(clippy::enum_variant_names)]
15677 enum GeneratedField {
15678 ContextId,
15679 UnpinVersionBefore,
15680 }
15681 impl<'de> serde::Deserialize<'de> for GeneratedField {
15682 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15683 where
15684 D: serde::Deserializer<'de>,
15685 {
15686 struct GeneratedVisitor;
15687
15688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15689 type Value = GeneratedField;
15690
15691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15692 write!(formatter, "expected one of: {:?}", &FIELDS)
15693 }
15694
15695 #[allow(unused_variables)]
15696 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15697 where
15698 E: serde::de::Error,
15699 {
15700 match value {
15701 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15702 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
15703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15704 }
15705 }
15706 }
15707 deserializer.deserialize_identifier(GeneratedVisitor)
15708 }
15709 }
15710 struct GeneratedVisitor;
15711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15712 type Value = UnpinVersionBeforeRequest;
15713
15714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15715 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
15716 }
15717
15718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
15719 where
15720 V: serde::de::MapAccess<'de>,
15721 {
15722 let mut context_id__ = None;
15723 let mut unpin_version_before__ = None;
15724 while let Some(k) = map_.next_key()? {
15725 match k {
15726 GeneratedField::ContextId => {
15727 if context_id__.is_some() {
15728 return Err(serde::de::Error::duplicate_field("contextId"));
15729 }
15730 context_id__ =
15731 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15732 ;
15733 }
15734 GeneratedField::UnpinVersionBefore => {
15735 if unpin_version_before__.is_some() {
15736 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
15737 }
15738 unpin_version_before__ =
15739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15740 ;
15741 }
15742 }
15743 }
15744 Ok(UnpinVersionBeforeRequest {
15745 context_id: context_id__.unwrap_or_default(),
15746 unpin_version_before: unpin_version_before__.unwrap_or_default(),
15747 })
15748 }
15749 }
15750 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
15751 }
15752}
15753impl serde::Serialize for UnpinVersionBeforeResponse {
15754 #[allow(deprecated)]
15755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15756 where
15757 S: serde::Serializer,
15758 {
15759 use serde::ser::SerializeStruct;
15760 let mut len = 0;
15761 if self.status.is_some() {
15762 len += 1;
15763 }
15764 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
15765 if let Some(v) = self.status.as_ref() {
15766 struct_ser.serialize_field("status", v)?;
15767 }
15768 struct_ser.end()
15769 }
15770}
15771impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
15772 #[allow(deprecated)]
15773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15774 where
15775 D: serde::Deserializer<'de>,
15776 {
15777 const FIELDS: &[&str] = &[
15778 "status",
15779 ];
15780
15781 #[allow(clippy::enum_variant_names)]
15782 enum GeneratedField {
15783 Status,
15784 }
15785 impl<'de> serde::Deserialize<'de> for GeneratedField {
15786 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15787 where
15788 D: serde::Deserializer<'de>,
15789 {
15790 struct GeneratedVisitor;
15791
15792 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15793 type Value = GeneratedField;
15794
15795 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15796 write!(formatter, "expected one of: {:?}", &FIELDS)
15797 }
15798
15799 #[allow(unused_variables)]
15800 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15801 where
15802 E: serde::de::Error,
15803 {
15804 match value {
15805 "status" => Ok(GeneratedField::Status),
15806 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15807 }
15808 }
15809 }
15810 deserializer.deserialize_identifier(GeneratedVisitor)
15811 }
15812 }
15813 struct GeneratedVisitor;
15814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15815 type Value = UnpinVersionBeforeResponse;
15816
15817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15818 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
15819 }
15820
15821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
15822 where
15823 V: serde::de::MapAccess<'de>,
15824 {
15825 let mut status__ = None;
15826 while let Some(k) = map_.next_key()? {
15827 match k {
15828 GeneratedField::Status => {
15829 if status__.is_some() {
15830 return Err(serde::de::Error::duplicate_field("status"));
15831 }
15832 status__ = map_.next_value()?;
15833 }
15834 }
15835 }
15836 Ok(UnpinVersionBeforeResponse {
15837 status: status__,
15838 })
15839 }
15840 }
15841 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
15842 }
15843}
15844impl serde::Serialize for UnpinVersionRequest {
15845 #[allow(deprecated)]
15846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15847 where
15848 S: serde::Serializer,
15849 {
15850 use serde::ser::SerializeStruct;
15851 let mut len = 0;
15852 if self.context_id != 0 {
15853 len += 1;
15854 }
15855 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
15856 if self.context_id != 0 {
15857 struct_ser.serialize_field("contextId", &self.context_id)?;
15858 }
15859 struct_ser.end()
15860 }
15861}
15862impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
15863 #[allow(deprecated)]
15864 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15865 where
15866 D: serde::Deserializer<'de>,
15867 {
15868 const FIELDS: &[&str] = &[
15869 "context_id",
15870 "contextId",
15871 ];
15872
15873 #[allow(clippy::enum_variant_names)]
15874 enum GeneratedField {
15875 ContextId,
15876 }
15877 impl<'de> serde::Deserialize<'de> for GeneratedField {
15878 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15879 where
15880 D: serde::Deserializer<'de>,
15881 {
15882 struct GeneratedVisitor;
15883
15884 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15885 type Value = GeneratedField;
15886
15887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15888 write!(formatter, "expected one of: {:?}", &FIELDS)
15889 }
15890
15891 #[allow(unused_variables)]
15892 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15893 where
15894 E: serde::de::Error,
15895 {
15896 match value {
15897 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15898 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15899 }
15900 }
15901 }
15902 deserializer.deserialize_identifier(GeneratedVisitor)
15903 }
15904 }
15905 struct GeneratedVisitor;
15906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15907 type Value = UnpinVersionRequest;
15908
15909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15910 formatter.write_str("struct hummock.UnpinVersionRequest")
15911 }
15912
15913 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
15914 where
15915 V: serde::de::MapAccess<'de>,
15916 {
15917 let mut context_id__ = None;
15918 while let Some(k) = map_.next_key()? {
15919 match k {
15920 GeneratedField::ContextId => {
15921 if context_id__.is_some() {
15922 return Err(serde::de::Error::duplicate_field("contextId"));
15923 }
15924 context_id__ =
15925 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15926 ;
15927 }
15928 }
15929 }
15930 Ok(UnpinVersionRequest {
15931 context_id: context_id__.unwrap_or_default(),
15932 })
15933 }
15934 }
15935 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
15936 }
15937}
15938impl serde::Serialize for UnpinVersionResponse {
15939 #[allow(deprecated)]
15940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15941 where
15942 S: serde::Serializer,
15943 {
15944 use serde::ser::SerializeStruct;
15945 let mut len = 0;
15946 if self.status.is_some() {
15947 len += 1;
15948 }
15949 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
15950 if let Some(v) = self.status.as_ref() {
15951 struct_ser.serialize_field("status", v)?;
15952 }
15953 struct_ser.end()
15954 }
15955}
15956impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
15957 #[allow(deprecated)]
15958 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15959 where
15960 D: serde::Deserializer<'de>,
15961 {
15962 const FIELDS: &[&str] = &[
15963 "status",
15964 ];
15965
15966 #[allow(clippy::enum_variant_names)]
15967 enum GeneratedField {
15968 Status,
15969 }
15970 impl<'de> serde::Deserialize<'de> for GeneratedField {
15971 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15972 where
15973 D: serde::Deserializer<'de>,
15974 {
15975 struct GeneratedVisitor;
15976
15977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15978 type Value = GeneratedField;
15979
15980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15981 write!(formatter, "expected one of: {:?}", &FIELDS)
15982 }
15983
15984 #[allow(unused_variables)]
15985 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15986 where
15987 E: serde::de::Error,
15988 {
15989 match value {
15990 "status" => Ok(GeneratedField::Status),
15991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15992 }
15993 }
15994 }
15995 deserializer.deserialize_identifier(GeneratedVisitor)
15996 }
15997 }
15998 struct GeneratedVisitor;
15999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16000 type Value = UnpinVersionResponse;
16001
16002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16003 formatter.write_str("struct hummock.UnpinVersionResponse")
16004 }
16005
16006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
16007 where
16008 V: serde::de::MapAccess<'de>,
16009 {
16010 let mut status__ = None;
16011 while let Some(k) = map_.next_key()? {
16012 match k {
16013 GeneratedField::Status => {
16014 if status__.is_some() {
16015 return Err(serde::de::Error::duplicate_field("status"));
16016 }
16017 status__ = map_.next_value()?;
16018 }
16019 }
16020 }
16021 Ok(UnpinVersionResponse {
16022 status: status__,
16023 })
16024 }
16025 }
16026 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
16027 }
16028}
16029impl serde::Serialize for VacuumTask {
16030 #[allow(deprecated)]
16031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16032 where
16033 S: serde::Serializer,
16034 {
16035 use serde::ser::SerializeStruct;
16036 let mut len = 0;
16037 if !self.sstable_object_ids.is_empty() {
16038 len += 1;
16039 }
16040 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
16041 if !self.sstable_object_ids.is_empty() {
16042 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16043 }
16044 struct_ser.end()
16045 }
16046}
16047impl<'de> serde::Deserialize<'de> for VacuumTask {
16048 #[allow(deprecated)]
16049 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16050 where
16051 D: serde::Deserializer<'de>,
16052 {
16053 const FIELDS: &[&str] = &[
16054 "sstable_object_ids",
16055 "sstableObjectIds",
16056 ];
16057
16058 #[allow(clippy::enum_variant_names)]
16059 enum GeneratedField {
16060 SstableObjectIds,
16061 }
16062 impl<'de> serde::Deserialize<'de> for GeneratedField {
16063 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16064 where
16065 D: serde::Deserializer<'de>,
16066 {
16067 struct GeneratedVisitor;
16068
16069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16070 type Value = GeneratedField;
16071
16072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16073 write!(formatter, "expected one of: {:?}", &FIELDS)
16074 }
16075
16076 #[allow(unused_variables)]
16077 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16078 where
16079 E: serde::de::Error,
16080 {
16081 match value {
16082 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
16083 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16084 }
16085 }
16086 }
16087 deserializer.deserialize_identifier(GeneratedVisitor)
16088 }
16089 }
16090 struct GeneratedVisitor;
16091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16092 type Value = VacuumTask;
16093
16094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16095 formatter.write_str("struct hummock.VacuumTask")
16096 }
16097
16098 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
16099 where
16100 V: serde::de::MapAccess<'de>,
16101 {
16102 let mut sstable_object_ids__ = None;
16103 while let Some(k) = map_.next_key()? {
16104 match k {
16105 GeneratedField::SstableObjectIds => {
16106 if sstable_object_ids__.is_some() {
16107 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
16108 }
16109 sstable_object_ids__ =
16110 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16111 .into_iter().map(|x| x.0).collect())
16112 ;
16113 }
16114 }
16115 }
16116 Ok(VacuumTask {
16117 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
16118 })
16119 }
16120 }
16121 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
16122 }
16123}
16124impl serde::Serialize for ValidationTask {
16125 #[allow(deprecated)]
16126 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16127 where
16128 S: serde::Serializer,
16129 {
16130 use serde::ser::SerializeStruct;
16131 let mut len = 0;
16132 if !self.sst_infos.is_empty() {
16133 len += 1;
16134 }
16135 if !self.sst_id_to_worker_id.is_empty() {
16136 len += 1;
16137 }
16138 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
16139 if !self.sst_infos.is_empty() {
16140 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
16141 }
16142 if !self.sst_id_to_worker_id.is_empty() {
16143 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
16144 }
16145 struct_ser.end()
16146 }
16147}
16148impl<'de> serde::Deserialize<'de> for ValidationTask {
16149 #[allow(deprecated)]
16150 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16151 where
16152 D: serde::Deserializer<'de>,
16153 {
16154 const FIELDS: &[&str] = &[
16155 "sst_infos",
16156 "sstInfos",
16157 "sst_id_to_worker_id",
16158 "sstIdToWorkerId",
16159 ];
16160
16161 #[allow(clippy::enum_variant_names)]
16162 enum GeneratedField {
16163 SstInfos,
16164 SstIdToWorkerId,
16165 }
16166 impl<'de> serde::Deserialize<'de> for GeneratedField {
16167 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16168 where
16169 D: serde::Deserializer<'de>,
16170 {
16171 struct GeneratedVisitor;
16172
16173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16174 type Value = GeneratedField;
16175
16176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16177 write!(formatter, "expected one of: {:?}", &FIELDS)
16178 }
16179
16180 #[allow(unused_variables)]
16181 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16182 where
16183 E: serde::de::Error,
16184 {
16185 match value {
16186 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
16187 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
16188 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16189 }
16190 }
16191 }
16192 deserializer.deserialize_identifier(GeneratedVisitor)
16193 }
16194 }
16195 struct GeneratedVisitor;
16196 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16197 type Value = ValidationTask;
16198
16199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16200 formatter.write_str("struct hummock.ValidationTask")
16201 }
16202
16203 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
16204 where
16205 V: serde::de::MapAccess<'de>,
16206 {
16207 let mut sst_infos__ = None;
16208 let mut sst_id_to_worker_id__ = None;
16209 while let Some(k) = map_.next_key()? {
16210 match k {
16211 GeneratedField::SstInfos => {
16212 if sst_infos__.is_some() {
16213 return Err(serde::de::Error::duplicate_field("sstInfos"));
16214 }
16215 sst_infos__ = Some(map_.next_value()?);
16216 }
16217 GeneratedField::SstIdToWorkerId => {
16218 if sst_id_to_worker_id__.is_some() {
16219 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
16220 }
16221 sst_id_to_worker_id__ = Some(
16222 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
16223 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
16224 );
16225 }
16226 }
16227 }
16228 Ok(ValidationTask {
16229 sst_infos: sst_infos__.unwrap_or_default(),
16230 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
16231 })
16232 }
16233 }
16234 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
16235 }
16236}
16237impl serde::Serialize for VectorFileInfo {
16238 #[allow(deprecated)]
16239 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16240 where
16241 S: serde::Serializer,
16242 {
16243 use serde::ser::SerializeStruct;
16244 let mut len = 0;
16245 if self.object_id != 0 {
16246 len += 1;
16247 }
16248 if self.file_size != 0 {
16249 len += 1;
16250 }
16251 if self.start_vector_id != 0 {
16252 len += 1;
16253 }
16254 if self.vector_count != 0 {
16255 len += 1;
16256 }
16257 if self.meta_offset != 0 {
16258 len += 1;
16259 }
16260 let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
16261 if self.object_id != 0 {
16262 #[allow(clippy::needless_borrow)]
16263 #[allow(clippy::needless_borrows_for_generic_args)]
16264 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
16265 }
16266 if self.file_size != 0 {
16267 #[allow(clippy::needless_borrow)]
16268 #[allow(clippy::needless_borrows_for_generic_args)]
16269 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
16270 }
16271 if self.start_vector_id != 0 {
16272 #[allow(clippy::needless_borrow)]
16273 #[allow(clippy::needless_borrows_for_generic_args)]
16274 struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
16275 }
16276 if self.vector_count != 0 {
16277 struct_ser.serialize_field("vectorCount", &self.vector_count)?;
16278 }
16279 if self.meta_offset != 0 {
16280 #[allow(clippy::needless_borrow)]
16281 #[allow(clippy::needless_borrows_for_generic_args)]
16282 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
16283 }
16284 struct_ser.end()
16285 }
16286}
16287impl<'de> serde::Deserialize<'de> for VectorFileInfo {
16288 #[allow(deprecated)]
16289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16290 where
16291 D: serde::Deserializer<'de>,
16292 {
16293 const FIELDS: &[&str] = &[
16294 "object_id",
16295 "objectId",
16296 "file_size",
16297 "fileSize",
16298 "start_vector_id",
16299 "startVectorId",
16300 "vector_count",
16301 "vectorCount",
16302 "meta_offset",
16303 "metaOffset",
16304 ];
16305
16306 #[allow(clippy::enum_variant_names)]
16307 enum GeneratedField {
16308 ObjectId,
16309 FileSize,
16310 StartVectorId,
16311 VectorCount,
16312 MetaOffset,
16313 }
16314 impl<'de> serde::Deserialize<'de> for GeneratedField {
16315 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16316 where
16317 D: serde::Deserializer<'de>,
16318 {
16319 struct GeneratedVisitor;
16320
16321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16322 type Value = GeneratedField;
16323
16324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16325 write!(formatter, "expected one of: {:?}", &FIELDS)
16326 }
16327
16328 #[allow(unused_variables)]
16329 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16330 where
16331 E: serde::de::Error,
16332 {
16333 match value {
16334 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
16335 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
16336 "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
16337 "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
16338 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
16339 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16340 }
16341 }
16342 }
16343 deserializer.deserialize_identifier(GeneratedVisitor)
16344 }
16345 }
16346 struct GeneratedVisitor;
16347 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16348 type Value = VectorFileInfo;
16349
16350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16351 formatter.write_str("struct hummock.VectorFileInfo")
16352 }
16353
16354 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
16355 where
16356 V: serde::de::MapAccess<'de>,
16357 {
16358 let mut object_id__ = None;
16359 let mut file_size__ = None;
16360 let mut start_vector_id__ = None;
16361 let mut vector_count__ = None;
16362 let mut meta_offset__ = None;
16363 while let Some(k) = map_.next_key()? {
16364 match k {
16365 GeneratedField::ObjectId => {
16366 if object_id__.is_some() {
16367 return Err(serde::de::Error::duplicate_field("objectId"));
16368 }
16369 object_id__ =
16370 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16371 ;
16372 }
16373 GeneratedField::FileSize => {
16374 if file_size__.is_some() {
16375 return Err(serde::de::Error::duplicate_field("fileSize"));
16376 }
16377 file_size__ =
16378 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16379 ;
16380 }
16381 GeneratedField::StartVectorId => {
16382 if start_vector_id__.is_some() {
16383 return Err(serde::de::Error::duplicate_field("startVectorId"));
16384 }
16385 start_vector_id__ =
16386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16387 ;
16388 }
16389 GeneratedField::VectorCount => {
16390 if vector_count__.is_some() {
16391 return Err(serde::de::Error::duplicate_field("vectorCount"));
16392 }
16393 vector_count__ =
16394 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16395 ;
16396 }
16397 GeneratedField::MetaOffset => {
16398 if meta_offset__.is_some() {
16399 return Err(serde::de::Error::duplicate_field("metaOffset"));
16400 }
16401 meta_offset__ =
16402 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16403 ;
16404 }
16405 }
16406 }
16407 Ok(VectorFileInfo {
16408 object_id: object_id__.unwrap_or_default(),
16409 file_size: file_size__.unwrap_or_default(),
16410 start_vector_id: start_vector_id__.unwrap_or_default(),
16411 vector_count: vector_count__.unwrap_or_default(),
16412 meta_offset: meta_offset__.unwrap_or_default(),
16413 })
16414 }
16415 }
16416 deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
16417 }
16418}
16419impl serde::Serialize for VectorIndex {
16420 #[allow(deprecated)]
16421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16422 where
16423 S: serde::Serializer,
16424 {
16425 use serde::ser::SerializeStruct;
16426 let mut len = 0;
16427 if self.dimension != 0 {
16428 len += 1;
16429 }
16430 if self.distance_type != 0 {
16431 len += 1;
16432 }
16433 if self.variant.is_some() {
16434 len += 1;
16435 }
16436 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
16437 if self.dimension != 0 {
16438 struct_ser.serialize_field("dimension", &self.dimension)?;
16439 }
16440 if self.distance_type != 0 {
16441 let v = super::common::DistanceType::try_from(self.distance_type)
16442 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
16443 struct_ser.serialize_field("distanceType", &v)?;
16444 }
16445 if let Some(v) = self.variant.as_ref() {
16446 match v {
16447 vector_index::Variant::Flat(v) => {
16448 struct_ser.serialize_field("flat", v)?;
16449 }
16450 }
16451 }
16452 struct_ser.end()
16453 }
16454}
16455impl<'de> serde::Deserialize<'de> for VectorIndex {
16456 #[allow(deprecated)]
16457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16458 where
16459 D: serde::Deserializer<'de>,
16460 {
16461 const FIELDS: &[&str] = &[
16462 "dimension",
16463 "distance_type",
16464 "distanceType",
16465 "flat",
16466 ];
16467
16468 #[allow(clippy::enum_variant_names)]
16469 enum GeneratedField {
16470 Dimension,
16471 DistanceType,
16472 Flat,
16473 }
16474 impl<'de> serde::Deserialize<'de> for GeneratedField {
16475 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16476 where
16477 D: serde::Deserializer<'de>,
16478 {
16479 struct GeneratedVisitor;
16480
16481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16482 type Value = GeneratedField;
16483
16484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16485 write!(formatter, "expected one of: {:?}", &FIELDS)
16486 }
16487
16488 #[allow(unused_variables)]
16489 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16490 where
16491 E: serde::de::Error,
16492 {
16493 match value {
16494 "dimension" => Ok(GeneratedField::Dimension),
16495 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
16496 "flat" => Ok(GeneratedField::Flat),
16497 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16498 }
16499 }
16500 }
16501 deserializer.deserialize_identifier(GeneratedVisitor)
16502 }
16503 }
16504 struct GeneratedVisitor;
16505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16506 type Value = VectorIndex;
16507
16508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16509 formatter.write_str("struct hummock.VectorIndex")
16510 }
16511
16512 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
16513 where
16514 V: serde::de::MapAccess<'de>,
16515 {
16516 let mut dimension__ = None;
16517 let mut distance_type__ = None;
16518 let mut variant__ = None;
16519 while let Some(k) = map_.next_key()? {
16520 match k {
16521 GeneratedField::Dimension => {
16522 if dimension__.is_some() {
16523 return Err(serde::de::Error::duplicate_field("dimension"));
16524 }
16525 dimension__ =
16526 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16527 ;
16528 }
16529 GeneratedField::DistanceType => {
16530 if distance_type__.is_some() {
16531 return Err(serde::de::Error::duplicate_field("distanceType"));
16532 }
16533 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
16534 }
16535 GeneratedField::Flat => {
16536 if variant__.is_some() {
16537 return Err(serde::de::Error::duplicate_field("flat"));
16538 }
16539 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
16540;
16541 }
16542 }
16543 }
16544 Ok(VectorIndex {
16545 dimension: dimension__.unwrap_or_default(),
16546 distance_type: distance_type__.unwrap_or_default(),
16547 variant: variant__,
16548 })
16549 }
16550 }
16551 deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
16552 }
16553}
16554impl serde::Serialize for VectorIndexDelta {
16555 #[allow(deprecated)]
16556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16557 where
16558 S: serde::Serializer,
16559 {
16560 use serde::ser::SerializeStruct;
16561 let mut len = 0;
16562 if self.delta.is_some() {
16563 len += 1;
16564 }
16565 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
16566 if let Some(v) = self.delta.as_ref() {
16567 match v {
16568 vector_index_delta::Delta::Init(v) => {
16569 struct_ser.serialize_field("init", v)?;
16570 }
16571 vector_index_delta::Delta::Adds(v) => {
16572 struct_ser.serialize_field("adds", v)?;
16573 }
16574 }
16575 }
16576 struct_ser.end()
16577 }
16578}
16579impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
16580 #[allow(deprecated)]
16581 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16582 where
16583 D: serde::Deserializer<'de>,
16584 {
16585 const FIELDS: &[&str] = &[
16586 "init",
16587 "adds",
16588 ];
16589
16590 #[allow(clippy::enum_variant_names)]
16591 enum GeneratedField {
16592 Init,
16593 Adds,
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 "init" => Ok(GeneratedField::Init),
16616 "adds" => Ok(GeneratedField::Adds),
16617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16618 }
16619 }
16620 }
16621 deserializer.deserialize_identifier(GeneratedVisitor)
16622 }
16623 }
16624 struct GeneratedVisitor;
16625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16626 type Value = VectorIndexDelta;
16627
16628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16629 formatter.write_str("struct hummock.VectorIndexDelta")
16630 }
16631
16632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
16633 where
16634 V: serde::de::MapAccess<'de>,
16635 {
16636 let mut delta__ = None;
16637 while let Some(k) = map_.next_key()? {
16638 match k {
16639 GeneratedField::Init => {
16640 if delta__.is_some() {
16641 return Err(serde::de::Error::duplicate_field("init"));
16642 }
16643 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
16644;
16645 }
16646 GeneratedField::Adds => {
16647 if delta__.is_some() {
16648 return Err(serde::de::Error::duplicate_field("adds"));
16649 }
16650 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
16651;
16652 }
16653 }
16654 }
16655 Ok(VectorIndexDelta {
16656 delta: delta__,
16657 })
16658 }
16659 }
16660 deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
16661 }
16662}
16663impl serde::Serialize for vector_index_delta::VectorIndexAdd {
16664 #[allow(deprecated)]
16665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16666 where
16667 S: serde::Serializer,
16668 {
16669 use serde::ser::SerializeStruct;
16670 let mut len = 0;
16671 if self.add.is_some() {
16672 len += 1;
16673 }
16674 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
16675 if let Some(v) = self.add.as_ref() {
16676 match v {
16677 vector_index_delta::vector_index_add::Add::Flat(v) => {
16678 struct_ser.serialize_field("flat", v)?;
16679 }
16680 }
16681 }
16682 struct_ser.end()
16683 }
16684}
16685impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
16686 #[allow(deprecated)]
16687 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16688 where
16689 D: serde::Deserializer<'de>,
16690 {
16691 const FIELDS: &[&str] = &[
16692 "flat",
16693 ];
16694
16695 #[allow(clippy::enum_variant_names)]
16696 enum GeneratedField {
16697 Flat,
16698 }
16699 impl<'de> serde::Deserialize<'de> for GeneratedField {
16700 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16701 where
16702 D: serde::Deserializer<'de>,
16703 {
16704 struct GeneratedVisitor;
16705
16706 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16707 type Value = GeneratedField;
16708
16709 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16710 write!(formatter, "expected one of: {:?}", &FIELDS)
16711 }
16712
16713 #[allow(unused_variables)]
16714 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16715 where
16716 E: serde::de::Error,
16717 {
16718 match value {
16719 "flat" => Ok(GeneratedField::Flat),
16720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16721 }
16722 }
16723 }
16724 deserializer.deserialize_identifier(GeneratedVisitor)
16725 }
16726 }
16727 struct GeneratedVisitor;
16728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16729 type Value = vector_index_delta::VectorIndexAdd;
16730
16731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16732 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
16733 }
16734
16735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
16736 where
16737 V: serde::de::MapAccess<'de>,
16738 {
16739 let mut add__ = None;
16740 while let Some(k) = map_.next_key()? {
16741 match k {
16742 GeneratedField::Flat => {
16743 if add__.is_some() {
16744 return Err(serde::de::Error::duplicate_field("flat"));
16745 }
16746 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
16747;
16748 }
16749 }
16750 }
16751 Ok(vector_index_delta::VectorIndexAdd {
16752 add: add__,
16753 })
16754 }
16755 }
16756 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
16757 }
16758}
16759impl serde::Serialize for vector_index_delta::VectorIndexAdds {
16760 #[allow(deprecated)]
16761 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16762 where
16763 S: serde::Serializer,
16764 {
16765 use serde::ser::SerializeStruct;
16766 let mut len = 0;
16767 if !self.adds.is_empty() {
16768 len += 1;
16769 }
16770 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
16771 if !self.adds.is_empty() {
16772 struct_ser.serialize_field("adds", &self.adds)?;
16773 }
16774 struct_ser.end()
16775 }
16776}
16777impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
16778 #[allow(deprecated)]
16779 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16780 where
16781 D: serde::Deserializer<'de>,
16782 {
16783 const FIELDS: &[&str] = &[
16784 "adds",
16785 ];
16786
16787 #[allow(clippy::enum_variant_names)]
16788 enum GeneratedField {
16789 Adds,
16790 }
16791 impl<'de> serde::Deserialize<'de> for GeneratedField {
16792 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16793 where
16794 D: serde::Deserializer<'de>,
16795 {
16796 struct GeneratedVisitor;
16797
16798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16799 type Value = GeneratedField;
16800
16801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16802 write!(formatter, "expected one of: {:?}", &FIELDS)
16803 }
16804
16805 #[allow(unused_variables)]
16806 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16807 where
16808 E: serde::de::Error,
16809 {
16810 match value {
16811 "adds" => Ok(GeneratedField::Adds),
16812 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16813 }
16814 }
16815 }
16816 deserializer.deserialize_identifier(GeneratedVisitor)
16817 }
16818 }
16819 struct GeneratedVisitor;
16820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16821 type Value = vector_index_delta::VectorIndexAdds;
16822
16823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16824 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
16825 }
16826
16827 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
16828 where
16829 V: serde::de::MapAccess<'de>,
16830 {
16831 let mut adds__ = None;
16832 while let Some(k) = map_.next_key()? {
16833 match k {
16834 GeneratedField::Adds => {
16835 if adds__.is_some() {
16836 return Err(serde::de::Error::duplicate_field("adds"));
16837 }
16838 adds__ = Some(map_.next_value()?);
16839 }
16840 }
16841 }
16842 Ok(vector_index_delta::VectorIndexAdds {
16843 adds: adds__.unwrap_or_default(),
16844 })
16845 }
16846 }
16847 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
16848 }
16849}
16850impl serde::Serialize for vector_index_delta::VectorIndexInit {
16851 #[allow(deprecated)]
16852 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16853 where
16854 S: serde::Serializer,
16855 {
16856 use serde::ser::SerializeStruct;
16857 let mut len = 0;
16858 if self.info.is_some() {
16859 len += 1;
16860 }
16861 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
16862 if let Some(v) = self.info.as_ref() {
16863 struct_ser.serialize_field("info", v)?;
16864 }
16865 struct_ser.end()
16866 }
16867}
16868impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
16869 #[allow(deprecated)]
16870 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16871 where
16872 D: serde::Deserializer<'de>,
16873 {
16874 const FIELDS: &[&str] = &[
16875 "info",
16876 ];
16877
16878 #[allow(clippy::enum_variant_names)]
16879 enum GeneratedField {
16880 Info,
16881 }
16882 impl<'de> serde::Deserialize<'de> for GeneratedField {
16883 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16884 where
16885 D: serde::Deserializer<'de>,
16886 {
16887 struct GeneratedVisitor;
16888
16889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16890 type Value = GeneratedField;
16891
16892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16893 write!(formatter, "expected one of: {:?}", &FIELDS)
16894 }
16895
16896 #[allow(unused_variables)]
16897 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16898 where
16899 E: serde::de::Error,
16900 {
16901 match value {
16902 "info" => Ok(GeneratedField::Info),
16903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16904 }
16905 }
16906 }
16907 deserializer.deserialize_identifier(GeneratedVisitor)
16908 }
16909 }
16910 struct GeneratedVisitor;
16911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16912 type Value = vector_index_delta::VectorIndexInit;
16913
16914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16915 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
16916 }
16917
16918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
16919 where
16920 V: serde::de::MapAccess<'de>,
16921 {
16922 let mut info__ = None;
16923 while let Some(k) = map_.next_key()? {
16924 match k {
16925 GeneratedField::Info => {
16926 if info__.is_some() {
16927 return Err(serde::de::Error::duplicate_field("info"));
16928 }
16929 info__ = map_.next_value()?;
16930 }
16931 }
16932 }
16933 Ok(vector_index_delta::VectorIndexInit {
16934 info: info__,
16935 })
16936 }
16937 }
16938 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
16939 }
16940}
16941impl serde::Serialize for VectorIndexObject {
16942 #[allow(deprecated)]
16943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16944 where
16945 S: serde::Serializer,
16946 {
16947 use serde::ser::SerializeStruct;
16948 let mut len = 0;
16949 if self.id != 0 {
16950 len += 1;
16951 }
16952 if self.object_type != 0 {
16953 len += 1;
16954 }
16955 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
16956 if self.id != 0 {
16957 #[allow(clippy::needless_borrow)]
16958 #[allow(clippy::needless_borrows_for_generic_args)]
16959 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
16960 }
16961 if self.object_type != 0 {
16962 let v = VectorIndexObjectType::try_from(self.object_type)
16963 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
16964 struct_ser.serialize_field("objectType", &v)?;
16965 }
16966 struct_ser.end()
16967 }
16968}
16969impl<'de> serde::Deserialize<'de> for VectorIndexObject {
16970 #[allow(deprecated)]
16971 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16972 where
16973 D: serde::Deserializer<'de>,
16974 {
16975 const FIELDS: &[&str] = &[
16976 "id",
16977 "object_type",
16978 "objectType",
16979 ];
16980
16981 #[allow(clippy::enum_variant_names)]
16982 enum GeneratedField {
16983 Id,
16984 ObjectType,
16985 }
16986 impl<'de> serde::Deserialize<'de> for GeneratedField {
16987 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16988 where
16989 D: serde::Deserializer<'de>,
16990 {
16991 struct GeneratedVisitor;
16992
16993 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16994 type Value = GeneratedField;
16995
16996 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16997 write!(formatter, "expected one of: {:?}", &FIELDS)
16998 }
16999
17000 #[allow(unused_variables)]
17001 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17002 where
17003 E: serde::de::Error,
17004 {
17005 match value {
17006 "id" => Ok(GeneratedField::Id),
17007 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
17008 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17009 }
17010 }
17011 }
17012 deserializer.deserialize_identifier(GeneratedVisitor)
17013 }
17014 }
17015 struct GeneratedVisitor;
17016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17017 type Value = VectorIndexObject;
17018
17019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17020 formatter.write_str("struct hummock.VectorIndexObject")
17021 }
17022
17023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
17024 where
17025 V: serde::de::MapAccess<'de>,
17026 {
17027 let mut id__ = None;
17028 let mut object_type__ = None;
17029 while let Some(k) = map_.next_key()? {
17030 match k {
17031 GeneratedField::Id => {
17032 if id__.is_some() {
17033 return Err(serde::de::Error::duplicate_field("id"));
17034 }
17035 id__ =
17036 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17037 ;
17038 }
17039 GeneratedField::ObjectType => {
17040 if object_type__.is_some() {
17041 return Err(serde::de::Error::duplicate_field("objectType"));
17042 }
17043 object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
17044 }
17045 }
17046 }
17047 Ok(VectorIndexObject {
17048 id: id__.unwrap_or_default(),
17049 object_type: object_type__.unwrap_or_default(),
17050 })
17051 }
17052 }
17053 deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
17054 }
17055}
17056impl serde::Serialize for VectorIndexObjectType {
17057 #[allow(deprecated)]
17058 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17059 where
17060 S: serde::Serializer,
17061 {
17062 let variant = match self {
17063 Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17064 Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
17065 };
17066 serializer.serialize_str(variant)
17067 }
17068}
17069impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
17070 #[allow(deprecated)]
17071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17072 where
17073 D: serde::Deserializer<'de>,
17074 {
17075 const FIELDS: &[&str] = &[
17076 "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17077 "VECTOR_INDEX_OBJECT_VECTOR",
17078 ];
17079
17080 struct GeneratedVisitor;
17081
17082 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17083 type Value = VectorIndexObjectType;
17084
17085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17086 write!(formatter, "expected one of: {:?}", &FIELDS)
17087 }
17088
17089 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17090 where
17091 E: serde::de::Error,
17092 {
17093 i32::try_from(v)
17094 .ok()
17095 .and_then(|x| x.try_into().ok())
17096 .ok_or_else(|| {
17097 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17098 })
17099 }
17100
17101 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17102 where
17103 E: serde::de::Error,
17104 {
17105 i32::try_from(v)
17106 .ok()
17107 .and_then(|x| x.try_into().ok())
17108 .ok_or_else(|| {
17109 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17110 })
17111 }
17112
17113 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17114 where
17115 E: serde::de::Error,
17116 {
17117 match value {
17118 "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
17119 "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
17120 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17121 }
17122 }
17123 }
17124 deserializer.deserialize_any(GeneratedVisitor)
17125 }
17126}
17127impl serde::Serialize for VersionUpdatePayload {
17128 #[allow(deprecated)]
17129 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17130 where
17131 S: serde::Serializer,
17132 {
17133 use serde::ser::SerializeStruct;
17134 let mut len = 0;
17135 if self.payload.is_some() {
17136 len += 1;
17137 }
17138 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
17139 if let Some(v) = self.payload.as_ref() {
17140 match v {
17141 version_update_payload::Payload::VersionDeltas(v) => {
17142 struct_ser.serialize_field("versionDeltas", v)?;
17143 }
17144 version_update_payload::Payload::PinnedVersion(v) => {
17145 struct_ser.serialize_field("pinnedVersion", v)?;
17146 }
17147 }
17148 }
17149 struct_ser.end()
17150 }
17151}
17152impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
17153 #[allow(deprecated)]
17154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17155 where
17156 D: serde::Deserializer<'de>,
17157 {
17158 const FIELDS: &[&str] = &[
17159 "version_deltas",
17160 "versionDeltas",
17161 "pinned_version",
17162 "pinnedVersion",
17163 ];
17164
17165 #[allow(clippy::enum_variant_names)]
17166 enum GeneratedField {
17167 VersionDeltas,
17168 PinnedVersion,
17169 }
17170 impl<'de> serde::Deserialize<'de> for GeneratedField {
17171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17172 where
17173 D: serde::Deserializer<'de>,
17174 {
17175 struct GeneratedVisitor;
17176
17177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17178 type Value = GeneratedField;
17179
17180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17181 write!(formatter, "expected one of: {:?}", &FIELDS)
17182 }
17183
17184 #[allow(unused_variables)]
17185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17186 where
17187 E: serde::de::Error,
17188 {
17189 match value {
17190 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
17191 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
17192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17193 }
17194 }
17195 }
17196 deserializer.deserialize_identifier(GeneratedVisitor)
17197 }
17198 }
17199 struct GeneratedVisitor;
17200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17201 type Value = VersionUpdatePayload;
17202
17203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17204 formatter.write_str("struct hummock.VersionUpdatePayload")
17205 }
17206
17207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
17208 where
17209 V: serde::de::MapAccess<'de>,
17210 {
17211 let mut payload__ = None;
17212 while let Some(k) = map_.next_key()? {
17213 match k {
17214 GeneratedField::VersionDeltas => {
17215 if payload__.is_some() {
17216 return Err(serde::de::Error::duplicate_field("versionDeltas"));
17217 }
17218 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
17219;
17220 }
17221 GeneratedField::PinnedVersion => {
17222 if payload__.is_some() {
17223 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
17224 }
17225 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
17226;
17227 }
17228 }
17229 }
17230 Ok(VersionUpdatePayload {
17231 payload: payload__,
17232 })
17233 }
17234 }
17235 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
17236 }
17237}
17238impl serde::Serialize for VnodeWatermark {
17239 #[allow(deprecated)]
17240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17241 where
17242 S: serde::Serializer,
17243 {
17244 use serde::ser::SerializeStruct;
17245 let mut len = 0;
17246 if !self.watermark.is_empty() {
17247 len += 1;
17248 }
17249 if self.vnode_bitmap.is_some() {
17250 len += 1;
17251 }
17252 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
17253 if !self.watermark.is_empty() {
17254 #[allow(clippy::needless_borrow)]
17255 #[allow(clippy::needless_borrows_for_generic_args)]
17256 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
17257 }
17258 if let Some(v) = self.vnode_bitmap.as_ref() {
17259 struct_ser.serialize_field("vnodeBitmap", v)?;
17260 }
17261 struct_ser.end()
17262 }
17263}
17264impl<'de> serde::Deserialize<'de> for VnodeWatermark {
17265 #[allow(deprecated)]
17266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17267 where
17268 D: serde::Deserializer<'de>,
17269 {
17270 const FIELDS: &[&str] = &[
17271 "watermark",
17272 "vnode_bitmap",
17273 "vnodeBitmap",
17274 ];
17275
17276 #[allow(clippy::enum_variant_names)]
17277 enum GeneratedField {
17278 Watermark,
17279 VnodeBitmap,
17280 }
17281 impl<'de> serde::Deserialize<'de> for GeneratedField {
17282 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17283 where
17284 D: serde::Deserializer<'de>,
17285 {
17286 struct GeneratedVisitor;
17287
17288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17289 type Value = GeneratedField;
17290
17291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17292 write!(formatter, "expected one of: {:?}", &FIELDS)
17293 }
17294
17295 #[allow(unused_variables)]
17296 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17297 where
17298 E: serde::de::Error,
17299 {
17300 match value {
17301 "watermark" => Ok(GeneratedField::Watermark),
17302 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
17303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17304 }
17305 }
17306 }
17307 deserializer.deserialize_identifier(GeneratedVisitor)
17308 }
17309 }
17310 struct GeneratedVisitor;
17311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17312 type Value = VnodeWatermark;
17313
17314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17315 formatter.write_str("struct hummock.VnodeWatermark")
17316 }
17317
17318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
17319 where
17320 V: serde::de::MapAccess<'de>,
17321 {
17322 let mut watermark__ = None;
17323 let mut vnode_bitmap__ = None;
17324 while let Some(k) = map_.next_key()? {
17325 match k {
17326 GeneratedField::Watermark => {
17327 if watermark__.is_some() {
17328 return Err(serde::de::Error::duplicate_field("watermark"));
17329 }
17330 watermark__ =
17331 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
17332 ;
17333 }
17334 GeneratedField::VnodeBitmap => {
17335 if vnode_bitmap__.is_some() {
17336 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
17337 }
17338 vnode_bitmap__ = map_.next_value()?;
17339 }
17340 }
17341 }
17342 Ok(VnodeWatermark {
17343 watermark: watermark__.unwrap_or_default(),
17344 vnode_bitmap: vnode_bitmap__,
17345 })
17346 }
17347 }
17348 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
17349 }
17350}
17351impl serde::Serialize for WriteLimits {
17352 #[allow(deprecated)]
17353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17354 where
17355 S: serde::Serializer,
17356 {
17357 use serde::ser::SerializeStruct;
17358 let mut len = 0;
17359 if !self.write_limits.is_empty() {
17360 len += 1;
17361 }
17362 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
17363 if !self.write_limits.is_empty() {
17364 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
17365 }
17366 struct_ser.end()
17367 }
17368}
17369impl<'de> serde::Deserialize<'de> for WriteLimits {
17370 #[allow(deprecated)]
17371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17372 where
17373 D: serde::Deserializer<'de>,
17374 {
17375 const FIELDS: &[&str] = &[
17376 "write_limits",
17377 "writeLimits",
17378 ];
17379
17380 #[allow(clippy::enum_variant_names)]
17381 enum GeneratedField {
17382 WriteLimits,
17383 }
17384 impl<'de> serde::Deserialize<'de> for GeneratedField {
17385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17386 where
17387 D: serde::Deserializer<'de>,
17388 {
17389 struct GeneratedVisitor;
17390
17391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17392 type Value = GeneratedField;
17393
17394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17395 write!(formatter, "expected one of: {:?}", &FIELDS)
17396 }
17397
17398 #[allow(unused_variables)]
17399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17400 where
17401 E: serde::de::Error,
17402 {
17403 match value {
17404 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
17405 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17406 }
17407 }
17408 }
17409 deserializer.deserialize_identifier(GeneratedVisitor)
17410 }
17411 }
17412 struct GeneratedVisitor;
17413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17414 type Value = WriteLimits;
17415
17416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17417 formatter.write_str("struct hummock.WriteLimits")
17418 }
17419
17420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
17421 where
17422 V: serde::de::MapAccess<'de>,
17423 {
17424 let mut write_limits__ = None;
17425 while let Some(k) = map_.next_key()? {
17426 match k {
17427 GeneratedField::WriteLimits => {
17428 if write_limits__.is_some() {
17429 return Err(serde::de::Error::duplicate_field("writeLimits"));
17430 }
17431 write_limits__ = Some(
17432 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
17433 .into_iter().map(|(k,v)| (k.0, v)).collect()
17434 );
17435 }
17436 }
17437 }
17438 Ok(WriteLimits {
17439 write_limits: write_limits__.unwrap_or_default(),
17440 })
17441 }
17442 }
17443 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
17444 }
17445}
17446impl serde::Serialize for write_limits::WriteLimit {
17447 #[allow(deprecated)]
17448 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17449 where
17450 S: serde::Serializer,
17451 {
17452 use serde::ser::SerializeStruct;
17453 let mut len = 0;
17454 if !self.table_ids.is_empty() {
17455 len += 1;
17456 }
17457 if !self.reason.is_empty() {
17458 len += 1;
17459 }
17460 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
17461 if !self.table_ids.is_empty() {
17462 struct_ser.serialize_field("tableIds", &self.table_ids)?;
17463 }
17464 if !self.reason.is_empty() {
17465 struct_ser.serialize_field("reason", &self.reason)?;
17466 }
17467 struct_ser.end()
17468 }
17469}
17470impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
17471 #[allow(deprecated)]
17472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17473 where
17474 D: serde::Deserializer<'de>,
17475 {
17476 const FIELDS: &[&str] = &[
17477 "table_ids",
17478 "tableIds",
17479 "reason",
17480 ];
17481
17482 #[allow(clippy::enum_variant_names)]
17483 enum GeneratedField {
17484 TableIds,
17485 Reason,
17486 }
17487 impl<'de> serde::Deserialize<'de> for GeneratedField {
17488 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17489 where
17490 D: serde::Deserializer<'de>,
17491 {
17492 struct GeneratedVisitor;
17493
17494 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17495 type Value = GeneratedField;
17496
17497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17498 write!(formatter, "expected one of: {:?}", &FIELDS)
17499 }
17500
17501 #[allow(unused_variables)]
17502 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17503 where
17504 E: serde::de::Error,
17505 {
17506 match value {
17507 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
17508 "reason" => Ok(GeneratedField::Reason),
17509 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17510 }
17511 }
17512 }
17513 deserializer.deserialize_identifier(GeneratedVisitor)
17514 }
17515 }
17516 struct GeneratedVisitor;
17517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17518 type Value = write_limits::WriteLimit;
17519
17520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17521 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
17522 }
17523
17524 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
17525 where
17526 V: serde::de::MapAccess<'de>,
17527 {
17528 let mut table_ids__ = None;
17529 let mut reason__ = None;
17530 while let Some(k) = map_.next_key()? {
17531 match k {
17532 GeneratedField::TableIds => {
17533 if table_ids__.is_some() {
17534 return Err(serde::de::Error::duplicate_field("tableIds"));
17535 }
17536 table_ids__ =
17537 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17538 .into_iter().map(|x| x.0).collect())
17539 ;
17540 }
17541 GeneratedField::Reason => {
17542 if reason__.is_some() {
17543 return Err(serde::de::Error::duplicate_field("reason"));
17544 }
17545 reason__ = Some(map_.next_value()?);
17546 }
17547 }
17548 }
17549 Ok(write_limits::WriteLimit {
17550 table_ids: table_ids__.unwrap_or_default(),
17551 reason: reason__.unwrap_or_default(),
17552 })
17553 }
17554 }
17555 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
17556 }
17557}