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 DistanceType {
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 let variant = match self {
3036 Self::Unspecified => "DISTANCE_TYPE_UNSPECIFIED",
3037 Self::L1 => "DISTANCE_TYPE_L1",
3038 Self::L2 => "DISTANCE_TYPE_L2",
3039 Self::Cosine => "DISTANCE_TYPE_COSINE",
3040 Self::InnerProduct => "DISTANCE_TYPE_INNER_PRODUCT",
3041 };
3042 serializer.serialize_str(variant)
3043 }
3044}
3045impl<'de> serde::Deserialize<'de> for DistanceType {
3046 #[allow(deprecated)]
3047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3048 where
3049 D: serde::Deserializer<'de>,
3050 {
3051 const FIELDS: &[&str] = &[
3052 "DISTANCE_TYPE_UNSPECIFIED",
3053 "DISTANCE_TYPE_L1",
3054 "DISTANCE_TYPE_L2",
3055 "DISTANCE_TYPE_COSINE",
3056 "DISTANCE_TYPE_INNER_PRODUCT",
3057 ];
3058
3059 struct GeneratedVisitor;
3060
3061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3062 type Value = DistanceType;
3063
3064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3065 write!(formatter, "expected one of: {:?}", &FIELDS)
3066 }
3067
3068 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3069 where
3070 E: serde::de::Error,
3071 {
3072 i32::try_from(v)
3073 .ok()
3074 .and_then(|x| x.try_into().ok())
3075 .ok_or_else(|| {
3076 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3077 })
3078 }
3079
3080 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3081 where
3082 E: serde::de::Error,
3083 {
3084 i32::try_from(v)
3085 .ok()
3086 .and_then(|x| x.try_into().ok())
3087 .ok_or_else(|| {
3088 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3089 })
3090 }
3091
3092 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3093 where
3094 E: serde::de::Error,
3095 {
3096 match value {
3097 "DISTANCE_TYPE_UNSPECIFIED" => Ok(DistanceType::Unspecified),
3098 "DISTANCE_TYPE_L1" => Ok(DistanceType::L1),
3099 "DISTANCE_TYPE_L2" => Ok(DistanceType::L2),
3100 "DISTANCE_TYPE_COSINE" => Ok(DistanceType::Cosine),
3101 "DISTANCE_TYPE_INNER_PRODUCT" => Ok(DistanceType::InnerProduct),
3102 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3103 }
3104 }
3105 }
3106 deserializer.deserialize_any(GeneratedVisitor)
3107 }
3108}
3109impl serde::Serialize for EpochNewChangeLog {
3110 #[allow(deprecated)]
3111 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3112 where
3113 S: serde::Serializer,
3114 {
3115 use serde::ser::SerializeStruct;
3116 let mut len = 0;
3117 if !self.old_value.is_empty() {
3118 len += 1;
3119 }
3120 if !self.new_value.is_empty() {
3121 len += 1;
3122 }
3123 if !self.epochs.is_empty() {
3124 len += 1;
3125 }
3126 let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3127 if !self.old_value.is_empty() {
3128 struct_ser.serialize_field("oldValue", &self.old_value)?;
3129 }
3130 if !self.new_value.is_empty() {
3131 struct_ser.serialize_field("newValue", &self.new_value)?;
3132 }
3133 if !self.epochs.is_empty() {
3134 struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3135 }
3136 struct_ser.end()
3137 }
3138}
3139impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3140 #[allow(deprecated)]
3141 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3142 where
3143 D: serde::Deserializer<'de>,
3144 {
3145 const FIELDS: &[&str] = &[
3146 "old_value",
3147 "oldValue",
3148 "new_value",
3149 "newValue",
3150 "epochs",
3151 ];
3152
3153 #[allow(clippy::enum_variant_names)]
3154 enum GeneratedField {
3155 OldValue,
3156 NewValue,
3157 Epochs,
3158 }
3159 impl<'de> serde::Deserialize<'de> for GeneratedField {
3160 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3161 where
3162 D: serde::Deserializer<'de>,
3163 {
3164 struct GeneratedVisitor;
3165
3166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3167 type Value = GeneratedField;
3168
3169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3170 write!(formatter, "expected one of: {:?}", &FIELDS)
3171 }
3172
3173 #[allow(unused_variables)]
3174 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3175 where
3176 E: serde::de::Error,
3177 {
3178 match value {
3179 "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3180 "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3181 "epochs" => Ok(GeneratedField::Epochs),
3182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3183 }
3184 }
3185 }
3186 deserializer.deserialize_identifier(GeneratedVisitor)
3187 }
3188 }
3189 struct GeneratedVisitor;
3190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3191 type Value = EpochNewChangeLog;
3192
3193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3194 formatter.write_str("struct hummock.EpochNewChangeLog")
3195 }
3196
3197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3198 where
3199 V: serde::de::MapAccess<'de>,
3200 {
3201 let mut old_value__ = None;
3202 let mut new_value__ = None;
3203 let mut epochs__ = None;
3204 while let Some(k) = map_.next_key()? {
3205 match k {
3206 GeneratedField::OldValue => {
3207 if old_value__.is_some() {
3208 return Err(serde::de::Error::duplicate_field("oldValue"));
3209 }
3210 old_value__ = Some(map_.next_value()?);
3211 }
3212 GeneratedField::NewValue => {
3213 if new_value__.is_some() {
3214 return Err(serde::de::Error::duplicate_field("newValue"));
3215 }
3216 new_value__ = Some(map_.next_value()?);
3217 }
3218 GeneratedField::Epochs => {
3219 if epochs__.is_some() {
3220 return Err(serde::de::Error::duplicate_field("epochs"));
3221 }
3222 epochs__ =
3223 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3224 .into_iter().map(|x| x.0).collect())
3225 ;
3226 }
3227 }
3228 }
3229 Ok(EpochNewChangeLog {
3230 old_value: old_value__.unwrap_or_default(),
3231 new_value: new_value__.unwrap_or_default(),
3232 epochs: epochs__.unwrap_or_default(),
3233 })
3234 }
3235 }
3236 deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3237 }
3238}
3239impl serde::Serialize for FlatIndex {
3240 #[allow(deprecated)]
3241 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3242 where
3243 S: serde::Serializer,
3244 {
3245 use serde::ser::SerializeStruct;
3246 let mut len = 0;
3247 if self.config.is_some() {
3248 len += 1;
3249 }
3250 if !self.vector_files.is_empty() {
3251 len += 1;
3252 }
3253 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3254 if let Some(v) = self.config.as_ref() {
3255 struct_ser.serialize_field("config", v)?;
3256 }
3257 if !self.vector_files.is_empty() {
3258 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3259 }
3260 struct_ser.end()
3261 }
3262}
3263impl<'de> serde::Deserialize<'de> for FlatIndex {
3264 #[allow(deprecated)]
3265 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3266 where
3267 D: serde::Deserializer<'de>,
3268 {
3269 const FIELDS: &[&str] = &[
3270 "config",
3271 "vector_files",
3272 "vectorFiles",
3273 ];
3274
3275 #[allow(clippy::enum_variant_names)]
3276 enum GeneratedField {
3277 Config,
3278 VectorFiles,
3279 }
3280 impl<'de> serde::Deserialize<'de> for GeneratedField {
3281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3282 where
3283 D: serde::Deserializer<'de>,
3284 {
3285 struct GeneratedVisitor;
3286
3287 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3288 type Value = GeneratedField;
3289
3290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3291 write!(formatter, "expected one of: {:?}", &FIELDS)
3292 }
3293
3294 #[allow(unused_variables)]
3295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3296 where
3297 E: serde::de::Error,
3298 {
3299 match value {
3300 "config" => Ok(GeneratedField::Config),
3301 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3302 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3303 }
3304 }
3305 }
3306 deserializer.deserialize_identifier(GeneratedVisitor)
3307 }
3308 }
3309 struct GeneratedVisitor;
3310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3311 type Value = FlatIndex;
3312
3313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3314 formatter.write_str("struct hummock.FlatIndex")
3315 }
3316
3317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3318 where
3319 V: serde::de::MapAccess<'de>,
3320 {
3321 let mut config__ = None;
3322 let mut vector_files__ = None;
3323 while let Some(k) = map_.next_key()? {
3324 match k {
3325 GeneratedField::Config => {
3326 if config__.is_some() {
3327 return Err(serde::de::Error::duplicate_field("config"));
3328 }
3329 config__ = map_.next_value()?;
3330 }
3331 GeneratedField::VectorFiles => {
3332 if vector_files__.is_some() {
3333 return Err(serde::de::Error::duplicate_field("vectorFiles"));
3334 }
3335 vector_files__ = Some(map_.next_value()?);
3336 }
3337 }
3338 }
3339 Ok(FlatIndex {
3340 config: config__,
3341 vector_files: vector_files__.unwrap_or_default(),
3342 })
3343 }
3344 }
3345 deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3346 }
3347}
3348impl serde::Serialize for FlatIndexAdd {
3349 #[allow(deprecated)]
3350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3351 where
3352 S: serde::Serializer,
3353 {
3354 use serde::ser::SerializeStruct;
3355 let mut len = 0;
3356 if !self.added_vector_files.is_empty() {
3357 len += 1;
3358 }
3359 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3360 if !self.added_vector_files.is_empty() {
3361 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3362 }
3363 struct_ser.end()
3364 }
3365}
3366impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3367 #[allow(deprecated)]
3368 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3369 where
3370 D: serde::Deserializer<'de>,
3371 {
3372 const FIELDS: &[&str] = &[
3373 "added_vector_files",
3374 "addedVectorFiles",
3375 ];
3376
3377 #[allow(clippy::enum_variant_names)]
3378 enum GeneratedField {
3379 AddedVectorFiles,
3380 }
3381 impl<'de> serde::Deserialize<'de> for GeneratedField {
3382 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3383 where
3384 D: serde::Deserializer<'de>,
3385 {
3386 struct GeneratedVisitor;
3387
3388 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3389 type Value = GeneratedField;
3390
3391 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3392 write!(formatter, "expected one of: {:?}", &FIELDS)
3393 }
3394
3395 #[allow(unused_variables)]
3396 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3397 where
3398 E: serde::de::Error,
3399 {
3400 match value {
3401 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3402 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3403 }
3404 }
3405 }
3406 deserializer.deserialize_identifier(GeneratedVisitor)
3407 }
3408 }
3409 struct GeneratedVisitor;
3410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3411 type Value = FlatIndexAdd;
3412
3413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3414 formatter.write_str("struct hummock.FlatIndexAdd")
3415 }
3416
3417 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3418 where
3419 V: serde::de::MapAccess<'de>,
3420 {
3421 let mut added_vector_files__ = None;
3422 while let Some(k) = map_.next_key()? {
3423 match k {
3424 GeneratedField::AddedVectorFiles => {
3425 if added_vector_files__.is_some() {
3426 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3427 }
3428 added_vector_files__ = Some(map_.next_value()?);
3429 }
3430 }
3431 }
3432 Ok(FlatIndexAdd {
3433 added_vector_files: added_vector_files__.unwrap_or_default(),
3434 })
3435 }
3436 }
3437 deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3438 }
3439}
3440impl serde::Serialize for FlatIndexConfig {
3441 #[allow(deprecated)]
3442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3443 where
3444 S: serde::Serializer,
3445 {
3446 use serde::ser::SerializeStruct;
3447 let len = 0;
3448 let struct_ser = serializer.serialize_struct("hummock.FlatIndexConfig", len)?;
3449 struct_ser.end()
3450 }
3451}
3452impl<'de> serde::Deserialize<'de> for FlatIndexConfig {
3453 #[allow(deprecated)]
3454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3455 where
3456 D: serde::Deserializer<'de>,
3457 {
3458 const FIELDS: &[&str] = &[
3459 ];
3460
3461 #[allow(clippy::enum_variant_names)]
3462 enum GeneratedField {
3463 }
3464 impl<'de> serde::Deserialize<'de> for GeneratedField {
3465 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3466 where
3467 D: serde::Deserializer<'de>,
3468 {
3469 struct GeneratedVisitor;
3470
3471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3472 type Value = GeneratedField;
3473
3474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3475 write!(formatter, "expected one of: {:?}", &FIELDS)
3476 }
3477
3478 #[allow(unused_variables)]
3479 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3480 where
3481 E: serde::de::Error,
3482 {
3483 Err(serde::de::Error::unknown_field(value, FIELDS))
3484 }
3485 }
3486 deserializer.deserialize_identifier(GeneratedVisitor)
3487 }
3488 }
3489 struct GeneratedVisitor;
3490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3491 type Value = FlatIndexConfig;
3492
3493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3494 formatter.write_str("struct hummock.FlatIndexConfig")
3495 }
3496
3497 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexConfig, V::Error>
3498 where
3499 V: serde::de::MapAccess<'de>,
3500 {
3501 while map_.next_key::<GeneratedField>()?.is_some() {
3502 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3503 }
3504 Ok(FlatIndexConfig {
3505 })
3506 }
3507 }
3508 deserializer.deserialize_struct("hummock.FlatIndexConfig", FIELDS, GeneratedVisitor)
3509 }
3510}
3511impl serde::Serialize for FullScanTask {
3512 #[allow(deprecated)]
3513 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3514 where
3515 S: serde::Serializer,
3516 {
3517 use serde::ser::SerializeStruct;
3518 let mut len = 0;
3519 if self.sst_retention_watermark != 0 {
3520 len += 1;
3521 }
3522 if self.prefix.is_some() {
3523 len += 1;
3524 }
3525 if self.start_after.is_some() {
3526 len += 1;
3527 }
3528 if self.limit.is_some() {
3529 len += 1;
3530 }
3531 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3532 if self.sst_retention_watermark != 0 {
3533 #[allow(clippy::needless_borrow)]
3534 #[allow(clippy::needless_borrows_for_generic_args)]
3535 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3536 }
3537 if let Some(v) = self.prefix.as_ref() {
3538 struct_ser.serialize_field("prefix", v)?;
3539 }
3540 if let Some(v) = self.start_after.as_ref() {
3541 struct_ser.serialize_field("startAfter", v)?;
3542 }
3543 if let Some(v) = self.limit.as_ref() {
3544 #[allow(clippy::needless_borrow)]
3545 #[allow(clippy::needless_borrows_for_generic_args)]
3546 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3547 }
3548 struct_ser.end()
3549 }
3550}
3551impl<'de> serde::Deserialize<'de> for FullScanTask {
3552 #[allow(deprecated)]
3553 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3554 where
3555 D: serde::Deserializer<'de>,
3556 {
3557 const FIELDS: &[&str] = &[
3558 "sst_retention_watermark",
3559 "sstRetentionWatermark",
3560 "prefix",
3561 "start_after",
3562 "startAfter",
3563 "limit",
3564 ];
3565
3566 #[allow(clippy::enum_variant_names)]
3567 enum GeneratedField {
3568 SstRetentionWatermark,
3569 Prefix,
3570 StartAfter,
3571 Limit,
3572 }
3573 impl<'de> serde::Deserialize<'de> for GeneratedField {
3574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3575 where
3576 D: serde::Deserializer<'de>,
3577 {
3578 struct GeneratedVisitor;
3579
3580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3581 type Value = GeneratedField;
3582
3583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3584 write!(formatter, "expected one of: {:?}", &FIELDS)
3585 }
3586
3587 #[allow(unused_variables)]
3588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3589 where
3590 E: serde::de::Error,
3591 {
3592 match value {
3593 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3594 "prefix" => Ok(GeneratedField::Prefix),
3595 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3596 "limit" => Ok(GeneratedField::Limit),
3597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3598 }
3599 }
3600 }
3601 deserializer.deserialize_identifier(GeneratedVisitor)
3602 }
3603 }
3604 struct GeneratedVisitor;
3605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3606 type Value = FullScanTask;
3607
3608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3609 formatter.write_str("struct hummock.FullScanTask")
3610 }
3611
3612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3613 where
3614 V: serde::de::MapAccess<'de>,
3615 {
3616 let mut sst_retention_watermark__ = None;
3617 let mut prefix__ = None;
3618 let mut start_after__ = None;
3619 let mut limit__ = None;
3620 while let Some(k) = map_.next_key()? {
3621 match k {
3622 GeneratedField::SstRetentionWatermark => {
3623 if sst_retention_watermark__.is_some() {
3624 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3625 }
3626 sst_retention_watermark__ =
3627 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3628 ;
3629 }
3630 GeneratedField::Prefix => {
3631 if prefix__.is_some() {
3632 return Err(serde::de::Error::duplicate_field("prefix"));
3633 }
3634 prefix__ = map_.next_value()?;
3635 }
3636 GeneratedField::StartAfter => {
3637 if start_after__.is_some() {
3638 return Err(serde::de::Error::duplicate_field("startAfter"));
3639 }
3640 start_after__ = map_.next_value()?;
3641 }
3642 GeneratedField::Limit => {
3643 if limit__.is_some() {
3644 return Err(serde::de::Error::duplicate_field("limit"));
3645 }
3646 limit__ =
3647 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3648 ;
3649 }
3650 }
3651 }
3652 Ok(FullScanTask {
3653 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3654 prefix: prefix__,
3655 start_after: start_after__,
3656 limit: limit__,
3657 })
3658 }
3659 }
3660 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3661 }
3662}
3663impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3664 #[allow(deprecated)]
3665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3666 where
3667 S: serde::Serializer,
3668 {
3669 use serde::ser::SerializeStruct;
3670 let len = 0;
3671 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3672 struct_ser.end()
3673 }
3674}
3675impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3676 #[allow(deprecated)]
3677 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3678 where
3679 D: serde::Deserializer<'de>,
3680 {
3681 const FIELDS: &[&str] = &[
3682 ];
3683
3684 #[allow(clippy::enum_variant_names)]
3685 enum GeneratedField {
3686 }
3687 impl<'de> serde::Deserialize<'de> for GeneratedField {
3688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3689 where
3690 D: serde::Deserializer<'de>,
3691 {
3692 struct GeneratedVisitor;
3693
3694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3695 type Value = GeneratedField;
3696
3697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3698 write!(formatter, "expected one of: {:?}", &FIELDS)
3699 }
3700
3701 #[allow(unused_variables)]
3702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3703 where
3704 E: serde::de::Error,
3705 {
3706 Err(serde::de::Error::unknown_field(value, FIELDS))
3707 }
3708 }
3709 deserializer.deserialize_identifier(GeneratedVisitor)
3710 }
3711 }
3712 struct GeneratedVisitor;
3713 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3714 type Value = GetAssignedCompactTaskNumRequest;
3715
3716 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3717 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3718 }
3719
3720 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3721 where
3722 V: serde::de::MapAccess<'de>,
3723 {
3724 while map_.next_key::<GeneratedField>()?.is_some() {
3725 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3726 }
3727 Ok(GetAssignedCompactTaskNumRequest {
3728 })
3729 }
3730 }
3731 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3732 }
3733}
3734impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3735 #[allow(deprecated)]
3736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3737 where
3738 S: serde::Serializer,
3739 {
3740 use serde::ser::SerializeStruct;
3741 let mut len = 0;
3742 if self.num_tasks != 0 {
3743 len += 1;
3744 }
3745 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3746 if self.num_tasks != 0 {
3747 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3748 }
3749 struct_ser.end()
3750 }
3751}
3752impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3753 #[allow(deprecated)]
3754 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3755 where
3756 D: serde::Deserializer<'de>,
3757 {
3758 const FIELDS: &[&str] = &[
3759 "num_tasks",
3760 "numTasks",
3761 ];
3762
3763 #[allow(clippy::enum_variant_names)]
3764 enum GeneratedField {
3765 NumTasks,
3766 }
3767 impl<'de> serde::Deserialize<'de> for GeneratedField {
3768 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3769 where
3770 D: serde::Deserializer<'de>,
3771 {
3772 struct GeneratedVisitor;
3773
3774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3775 type Value = GeneratedField;
3776
3777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3778 write!(formatter, "expected one of: {:?}", &FIELDS)
3779 }
3780
3781 #[allow(unused_variables)]
3782 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3783 where
3784 E: serde::de::Error,
3785 {
3786 match value {
3787 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3788 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3789 }
3790 }
3791 }
3792 deserializer.deserialize_identifier(GeneratedVisitor)
3793 }
3794 }
3795 struct GeneratedVisitor;
3796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3797 type Value = GetAssignedCompactTaskNumResponse;
3798
3799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3800 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3801 }
3802
3803 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3804 where
3805 V: serde::de::MapAccess<'de>,
3806 {
3807 let mut num_tasks__ = None;
3808 while let Some(k) = map_.next_key()? {
3809 match k {
3810 GeneratedField::NumTasks => {
3811 if num_tasks__.is_some() {
3812 return Err(serde::de::Error::duplicate_field("numTasks"));
3813 }
3814 num_tasks__ =
3815 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3816 ;
3817 }
3818 }
3819 }
3820 Ok(GetAssignedCompactTaskNumResponse {
3821 num_tasks: num_tasks__.unwrap_or_default(),
3822 })
3823 }
3824 }
3825 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3826 }
3827}
3828impl serde::Serialize for GetCompactionScoreRequest {
3829 #[allow(deprecated)]
3830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3831 where
3832 S: serde::Serializer,
3833 {
3834 use serde::ser::SerializeStruct;
3835 let mut len = 0;
3836 if self.compaction_group_id != 0 {
3837 len += 1;
3838 }
3839 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3840 if self.compaction_group_id != 0 {
3841 #[allow(clippy::needless_borrow)]
3842 #[allow(clippy::needless_borrows_for_generic_args)]
3843 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3844 }
3845 struct_ser.end()
3846 }
3847}
3848impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3849 #[allow(deprecated)]
3850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3851 where
3852 D: serde::Deserializer<'de>,
3853 {
3854 const FIELDS: &[&str] = &[
3855 "compaction_group_id",
3856 "compactionGroupId",
3857 ];
3858
3859 #[allow(clippy::enum_variant_names)]
3860 enum GeneratedField {
3861 CompactionGroupId,
3862 }
3863 impl<'de> serde::Deserialize<'de> for GeneratedField {
3864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3865 where
3866 D: serde::Deserializer<'de>,
3867 {
3868 struct GeneratedVisitor;
3869
3870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3871 type Value = GeneratedField;
3872
3873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3874 write!(formatter, "expected one of: {:?}", &FIELDS)
3875 }
3876
3877 #[allow(unused_variables)]
3878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3879 where
3880 E: serde::de::Error,
3881 {
3882 match value {
3883 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3884 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3885 }
3886 }
3887 }
3888 deserializer.deserialize_identifier(GeneratedVisitor)
3889 }
3890 }
3891 struct GeneratedVisitor;
3892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3893 type Value = GetCompactionScoreRequest;
3894
3895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3896 formatter.write_str("struct hummock.GetCompactionScoreRequest")
3897 }
3898
3899 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3900 where
3901 V: serde::de::MapAccess<'de>,
3902 {
3903 let mut compaction_group_id__ = None;
3904 while let Some(k) = map_.next_key()? {
3905 match k {
3906 GeneratedField::CompactionGroupId => {
3907 if compaction_group_id__.is_some() {
3908 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3909 }
3910 compaction_group_id__ =
3911 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3912 ;
3913 }
3914 }
3915 }
3916 Ok(GetCompactionScoreRequest {
3917 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3918 })
3919 }
3920 }
3921 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
3922 }
3923}
3924impl serde::Serialize for GetCompactionScoreResponse {
3925 #[allow(deprecated)]
3926 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3927 where
3928 S: serde::Serializer,
3929 {
3930 use serde::ser::SerializeStruct;
3931 let mut len = 0;
3932 if self.compaction_group_id != 0 {
3933 len += 1;
3934 }
3935 if !self.scores.is_empty() {
3936 len += 1;
3937 }
3938 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
3939 if self.compaction_group_id != 0 {
3940 #[allow(clippy::needless_borrow)]
3941 #[allow(clippy::needless_borrows_for_generic_args)]
3942 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3943 }
3944 if !self.scores.is_empty() {
3945 struct_ser.serialize_field("scores", &self.scores)?;
3946 }
3947 struct_ser.end()
3948 }
3949}
3950impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
3951 #[allow(deprecated)]
3952 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3953 where
3954 D: serde::Deserializer<'de>,
3955 {
3956 const FIELDS: &[&str] = &[
3957 "compaction_group_id",
3958 "compactionGroupId",
3959 "scores",
3960 ];
3961
3962 #[allow(clippy::enum_variant_names)]
3963 enum GeneratedField {
3964 CompactionGroupId,
3965 Scores,
3966 }
3967 impl<'de> serde::Deserialize<'de> for GeneratedField {
3968 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3969 where
3970 D: serde::Deserializer<'de>,
3971 {
3972 struct GeneratedVisitor;
3973
3974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3975 type Value = GeneratedField;
3976
3977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3978 write!(formatter, "expected one of: {:?}", &FIELDS)
3979 }
3980
3981 #[allow(unused_variables)]
3982 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3983 where
3984 E: serde::de::Error,
3985 {
3986 match value {
3987 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3988 "scores" => Ok(GeneratedField::Scores),
3989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3990 }
3991 }
3992 }
3993 deserializer.deserialize_identifier(GeneratedVisitor)
3994 }
3995 }
3996 struct GeneratedVisitor;
3997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3998 type Value = GetCompactionScoreResponse;
3999
4000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4001 formatter.write_str("struct hummock.GetCompactionScoreResponse")
4002 }
4003
4004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
4005 where
4006 V: serde::de::MapAccess<'de>,
4007 {
4008 let mut compaction_group_id__ = None;
4009 let mut scores__ = None;
4010 while let Some(k) = map_.next_key()? {
4011 match k {
4012 GeneratedField::CompactionGroupId => {
4013 if compaction_group_id__.is_some() {
4014 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
4015 }
4016 compaction_group_id__ =
4017 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4018 ;
4019 }
4020 GeneratedField::Scores => {
4021 if scores__.is_some() {
4022 return Err(serde::de::Error::duplicate_field("scores"));
4023 }
4024 scores__ = Some(map_.next_value()?);
4025 }
4026 }
4027 }
4028 Ok(GetCompactionScoreResponse {
4029 compaction_group_id: compaction_group_id__.unwrap_or_default(),
4030 scores: scores__.unwrap_or_default(),
4031 })
4032 }
4033 }
4034 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
4035 }
4036}
4037impl serde::Serialize for get_compaction_score_response::PickerInfo {
4038 #[allow(deprecated)]
4039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4040 where
4041 S: serde::Serializer,
4042 {
4043 use serde::ser::SerializeStruct;
4044 let mut len = 0;
4045 if self.score != 0 {
4046 len += 1;
4047 }
4048 if self.select_level != 0 {
4049 len += 1;
4050 }
4051 if self.target_level != 0 {
4052 len += 1;
4053 }
4054 if !self.picker_type.is_empty() {
4055 len += 1;
4056 }
4057 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
4058 if self.score != 0 {
4059 #[allow(clippy::needless_borrow)]
4060 #[allow(clippy::needless_borrows_for_generic_args)]
4061 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
4062 }
4063 if self.select_level != 0 {
4064 #[allow(clippy::needless_borrow)]
4065 #[allow(clippy::needless_borrows_for_generic_args)]
4066 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
4067 }
4068 if self.target_level != 0 {
4069 #[allow(clippy::needless_borrow)]
4070 #[allow(clippy::needless_borrows_for_generic_args)]
4071 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
4072 }
4073 if !self.picker_type.is_empty() {
4074 struct_ser.serialize_field("pickerType", &self.picker_type)?;
4075 }
4076 struct_ser.end()
4077 }
4078}
4079impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
4080 #[allow(deprecated)]
4081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4082 where
4083 D: serde::Deserializer<'de>,
4084 {
4085 const FIELDS: &[&str] = &[
4086 "score",
4087 "select_level",
4088 "selectLevel",
4089 "target_level",
4090 "targetLevel",
4091 "picker_type",
4092 "pickerType",
4093 ];
4094
4095 #[allow(clippy::enum_variant_names)]
4096 enum GeneratedField {
4097 Score,
4098 SelectLevel,
4099 TargetLevel,
4100 PickerType,
4101 }
4102 impl<'de> serde::Deserialize<'de> for GeneratedField {
4103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4104 where
4105 D: serde::Deserializer<'de>,
4106 {
4107 struct GeneratedVisitor;
4108
4109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4110 type Value = GeneratedField;
4111
4112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4113 write!(formatter, "expected one of: {:?}", &FIELDS)
4114 }
4115
4116 #[allow(unused_variables)]
4117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4118 where
4119 E: serde::de::Error,
4120 {
4121 match value {
4122 "score" => Ok(GeneratedField::Score),
4123 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4124 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4125 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4127 }
4128 }
4129 }
4130 deserializer.deserialize_identifier(GeneratedVisitor)
4131 }
4132 }
4133 struct GeneratedVisitor;
4134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4135 type Value = get_compaction_score_response::PickerInfo;
4136
4137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4138 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4139 }
4140
4141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4142 where
4143 V: serde::de::MapAccess<'de>,
4144 {
4145 let mut score__ = None;
4146 let mut select_level__ = None;
4147 let mut target_level__ = None;
4148 let mut picker_type__ = None;
4149 while let Some(k) = map_.next_key()? {
4150 match k {
4151 GeneratedField::Score => {
4152 if score__.is_some() {
4153 return Err(serde::de::Error::duplicate_field("score"));
4154 }
4155 score__ =
4156 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4157 ;
4158 }
4159 GeneratedField::SelectLevel => {
4160 if select_level__.is_some() {
4161 return Err(serde::de::Error::duplicate_field("selectLevel"));
4162 }
4163 select_level__ =
4164 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4165 ;
4166 }
4167 GeneratedField::TargetLevel => {
4168 if target_level__.is_some() {
4169 return Err(serde::de::Error::duplicate_field("targetLevel"));
4170 }
4171 target_level__ =
4172 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4173 ;
4174 }
4175 GeneratedField::PickerType => {
4176 if picker_type__.is_some() {
4177 return Err(serde::de::Error::duplicate_field("pickerType"));
4178 }
4179 picker_type__ = Some(map_.next_value()?);
4180 }
4181 }
4182 }
4183 Ok(get_compaction_score_response::PickerInfo {
4184 score: score__.unwrap_or_default(),
4185 select_level: select_level__.unwrap_or_default(),
4186 target_level: target_level__.unwrap_or_default(),
4187 picker_type: picker_type__.unwrap_or_default(),
4188 })
4189 }
4190 }
4191 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4192 }
4193}
4194impl serde::Serialize for GetCurrentVersionRequest {
4195 #[allow(deprecated)]
4196 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4197 where
4198 S: serde::Serializer,
4199 {
4200 use serde::ser::SerializeStruct;
4201 let len = 0;
4202 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4203 struct_ser.end()
4204 }
4205}
4206impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4207 #[allow(deprecated)]
4208 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4209 where
4210 D: serde::Deserializer<'de>,
4211 {
4212 const FIELDS: &[&str] = &[
4213 ];
4214
4215 #[allow(clippy::enum_variant_names)]
4216 enum GeneratedField {
4217 }
4218 impl<'de> serde::Deserialize<'de> for GeneratedField {
4219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4220 where
4221 D: serde::Deserializer<'de>,
4222 {
4223 struct GeneratedVisitor;
4224
4225 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4226 type Value = GeneratedField;
4227
4228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4229 write!(formatter, "expected one of: {:?}", &FIELDS)
4230 }
4231
4232 #[allow(unused_variables)]
4233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4234 where
4235 E: serde::de::Error,
4236 {
4237 Err(serde::de::Error::unknown_field(value, FIELDS))
4238 }
4239 }
4240 deserializer.deserialize_identifier(GeneratedVisitor)
4241 }
4242 }
4243 struct GeneratedVisitor;
4244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4245 type Value = GetCurrentVersionRequest;
4246
4247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4248 formatter.write_str("struct hummock.GetCurrentVersionRequest")
4249 }
4250
4251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4252 where
4253 V: serde::de::MapAccess<'de>,
4254 {
4255 while map_.next_key::<GeneratedField>()?.is_some() {
4256 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4257 }
4258 Ok(GetCurrentVersionRequest {
4259 })
4260 }
4261 }
4262 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4263 }
4264}
4265impl serde::Serialize for GetCurrentVersionResponse {
4266 #[allow(deprecated)]
4267 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4268 where
4269 S: serde::Serializer,
4270 {
4271 use serde::ser::SerializeStruct;
4272 let mut len = 0;
4273 if self.status.is_some() {
4274 len += 1;
4275 }
4276 if self.current_version.is_some() {
4277 len += 1;
4278 }
4279 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4280 if let Some(v) = self.status.as_ref() {
4281 struct_ser.serialize_field("status", v)?;
4282 }
4283 if let Some(v) = self.current_version.as_ref() {
4284 struct_ser.serialize_field("currentVersion", v)?;
4285 }
4286 struct_ser.end()
4287 }
4288}
4289impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4290 #[allow(deprecated)]
4291 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4292 where
4293 D: serde::Deserializer<'de>,
4294 {
4295 const FIELDS: &[&str] = &[
4296 "status",
4297 "current_version",
4298 "currentVersion",
4299 ];
4300
4301 #[allow(clippy::enum_variant_names)]
4302 enum GeneratedField {
4303 Status,
4304 CurrentVersion,
4305 }
4306 impl<'de> serde::Deserialize<'de> for GeneratedField {
4307 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4308 where
4309 D: serde::Deserializer<'de>,
4310 {
4311 struct GeneratedVisitor;
4312
4313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4314 type Value = GeneratedField;
4315
4316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4317 write!(formatter, "expected one of: {:?}", &FIELDS)
4318 }
4319
4320 #[allow(unused_variables)]
4321 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4322 where
4323 E: serde::de::Error,
4324 {
4325 match value {
4326 "status" => Ok(GeneratedField::Status),
4327 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4328 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4329 }
4330 }
4331 }
4332 deserializer.deserialize_identifier(GeneratedVisitor)
4333 }
4334 }
4335 struct GeneratedVisitor;
4336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4337 type Value = GetCurrentVersionResponse;
4338
4339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4340 formatter.write_str("struct hummock.GetCurrentVersionResponse")
4341 }
4342
4343 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4344 where
4345 V: serde::de::MapAccess<'de>,
4346 {
4347 let mut status__ = None;
4348 let mut current_version__ = None;
4349 while let Some(k) = map_.next_key()? {
4350 match k {
4351 GeneratedField::Status => {
4352 if status__.is_some() {
4353 return Err(serde::de::Error::duplicate_field("status"));
4354 }
4355 status__ = map_.next_value()?;
4356 }
4357 GeneratedField::CurrentVersion => {
4358 if current_version__.is_some() {
4359 return Err(serde::de::Error::duplicate_field("currentVersion"));
4360 }
4361 current_version__ = map_.next_value()?;
4362 }
4363 }
4364 }
4365 Ok(GetCurrentVersionResponse {
4366 status: status__,
4367 current_version: current_version__,
4368 })
4369 }
4370 }
4371 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4372 }
4373}
4374impl serde::Serialize for GetNewObjectIdsRequest {
4375 #[allow(deprecated)]
4376 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4377 where
4378 S: serde::Serializer,
4379 {
4380 use serde::ser::SerializeStruct;
4381 let mut len = 0;
4382 if self.number != 0 {
4383 len += 1;
4384 }
4385 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4386 if self.number != 0 {
4387 struct_ser.serialize_field("number", &self.number)?;
4388 }
4389 struct_ser.end()
4390 }
4391}
4392impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4393 #[allow(deprecated)]
4394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4395 where
4396 D: serde::Deserializer<'de>,
4397 {
4398 const FIELDS: &[&str] = &[
4399 "number",
4400 ];
4401
4402 #[allow(clippy::enum_variant_names)]
4403 enum GeneratedField {
4404 Number,
4405 }
4406 impl<'de> serde::Deserialize<'de> for GeneratedField {
4407 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4408 where
4409 D: serde::Deserializer<'de>,
4410 {
4411 struct GeneratedVisitor;
4412
4413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4414 type Value = GeneratedField;
4415
4416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4417 write!(formatter, "expected one of: {:?}", &FIELDS)
4418 }
4419
4420 #[allow(unused_variables)]
4421 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4422 where
4423 E: serde::de::Error,
4424 {
4425 match value {
4426 "number" => Ok(GeneratedField::Number),
4427 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4428 }
4429 }
4430 }
4431 deserializer.deserialize_identifier(GeneratedVisitor)
4432 }
4433 }
4434 struct GeneratedVisitor;
4435 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4436 type Value = GetNewObjectIdsRequest;
4437
4438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4439 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4440 }
4441
4442 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4443 where
4444 V: serde::de::MapAccess<'de>,
4445 {
4446 let mut number__ = None;
4447 while let Some(k) = map_.next_key()? {
4448 match k {
4449 GeneratedField::Number => {
4450 if number__.is_some() {
4451 return Err(serde::de::Error::duplicate_field("number"));
4452 }
4453 number__ =
4454 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4455 ;
4456 }
4457 }
4458 }
4459 Ok(GetNewObjectIdsRequest {
4460 number: number__.unwrap_or_default(),
4461 })
4462 }
4463 }
4464 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4465 }
4466}
4467impl serde::Serialize for GetNewObjectIdsResponse {
4468 #[allow(deprecated)]
4469 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4470 where
4471 S: serde::Serializer,
4472 {
4473 use serde::ser::SerializeStruct;
4474 let mut len = 0;
4475 if self.status.is_some() {
4476 len += 1;
4477 }
4478 if self.start_id != 0 {
4479 len += 1;
4480 }
4481 if self.end_id != 0 {
4482 len += 1;
4483 }
4484 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4485 if let Some(v) = self.status.as_ref() {
4486 struct_ser.serialize_field("status", v)?;
4487 }
4488 if self.start_id != 0 {
4489 #[allow(clippy::needless_borrow)]
4490 #[allow(clippy::needless_borrows_for_generic_args)]
4491 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4492 }
4493 if self.end_id != 0 {
4494 #[allow(clippy::needless_borrow)]
4495 #[allow(clippy::needless_borrows_for_generic_args)]
4496 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4497 }
4498 struct_ser.end()
4499 }
4500}
4501impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4502 #[allow(deprecated)]
4503 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4504 where
4505 D: serde::Deserializer<'de>,
4506 {
4507 const FIELDS: &[&str] = &[
4508 "status",
4509 "start_id",
4510 "startId",
4511 "end_id",
4512 "endId",
4513 ];
4514
4515 #[allow(clippy::enum_variant_names)]
4516 enum GeneratedField {
4517 Status,
4518 StartId,
4519 EndId,
4520 }
4521 impl<'de> serde::Deserialize<'de> for GeneratedField {
4522 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4523 where
4524 D: serde::Deserializer<'de>,
4525 {
4526 struct GeneratedVisitor;
4527
4528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4529 type Value = GeneratedField;
4530
4531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4532 write!(formatter, "expected one of: {:?}", &FIELDS)
4533 }
4534
4535 #[allow(unused_variables)]
4536 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4537 where
4538 E: serde::de::Error,
4539 {
4540 match value {
4541 "status" => Ok(GeneratedField::Status),
4542 "startId" | "start_id" => Ok(GeneratedField::StartId),
4543 "endId" | "end_id" => Ok(GeneratedField::EndId),
4544 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4545 }
4546 }
4547 }
4548 deserializer.deserialize_identifier(GeneratedVisitor)
4549 }
4550 }
4551 struct GeneratedVisitor;
4552 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4553 type Value = GetNewObjectIdsResponse;
4554
4555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4556 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4557 }
4558
4559 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4560 where
4561 V: serde::de::MapAccess<'de>,
4562 {
4563 let mut status__ = None;
4564 let mut start_id__ = None;
4565 let mut end_id__ = None;
4566 while let Some(k) = map_.next_key()? {
4567 match k {
4568 GeneratedField::Status => {
4569 if status__.is_some() {
4570 return Err(serde::de::Error::duplicate_field("status"));
4571 }
4572 status__ = map_.next_value()?;
4573 }
4574 GeneratedField::StartId => {
4575 if start_id__.is_some() {
4576 return Err(serde::de::Error::duplicate_field("startId"));
4577 }
4578 start_id__ =
4579 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4580 ;
4581 }
4582 GeneratedField::EndId => {
4583 if end_id__.is_some() {
4584 return Err(serde::de::Error::duplicate_field("endId"));
4585 }
4586 end_id__ =
4587 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4588 ;
4589 }
4590 }
4591 }
4592 Ok(GetNewObjectIdsResponse {
4593 status: status__,
4594 start_id: start_id__.unwrap_or_default(),
4595 end_id: end_id__.unwrap_or_default(),
4596 })
4597 }
4598 }
4599 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4600 }
4601}
4602impl serde::Serialize for GetVersionByEpochRequest {
4603 #[allow(deprecated)]
4604 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4605 where
4606 S: serde::Serializer,
4607 {
4608 use serde::ser::SerializeStruct;
4609 let mut len = 0;
4610 if self.epoch != 0 {
4611 len += 1;
4612 }
4613 if self.table_id != 0 {
4614 len += 1;
4615 }
4616 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
4617 if self.epoch != 0 {
4618 #[allow(clippy::needless_borrow)]
4619 #[allow(clippy::needless_borrows_for_generic_args)]
4620 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
4621 }
4622 if self.table_id != 0 {
4623 struct_ser.serialize_field("tableId", &self.table_id)?;
4624 }
4625 struct_ser.end()
4626 }
4627}
4628impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
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 "epoch",
4636 "table_id",
4637 "tableId",
4638 ];
4639
4640 #[allow(clippy::enum_variant_names)]
4641 enum GeneratedField {
4642 Epoch,
4643 TableId,
4644 }
4645 impl<'de> serde::Deserialize<'de> for GeneratedField {
4646 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4647 where
4648 D: serde::Deserializer<'de>,
4649 {
4650 struct GeneratedVisitor;
4651
4652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4653 type Value = GeneratedField;
4654
4655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4656 write!(formatter, "expected one of: {:?}", &FIELDS)
4657 }
4658
4659 #[allow(unused_variables)]
4660 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4661 where
4662 E: serde::de::Error,
4663 {
4664 match value {
4665 "epoch" => Ok(GeneratedField::Epoch),
4666 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4667 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4668 }
4669 }
4670 }
4671 deserializer.deserialize_identifier(GeneratedVisitor)
4672 }
4673 }
4674 struct GeneratedVisitor;
4675 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4676 type Value = GetVersionByEpochRequest;
4677
4678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4679 formatter.write_str("struct hummock.GetVersionByEpochRequest")
4680 }
4681
4682 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
4683 where
4684 V: serde::de::MapAccess<'de>,
4685 {
4686 let mut epoch__ = None;
4687 let mut table_id__ = None;
4688 while let Some(k) = map_.next_key()? {
4689 match k {
4690 GeneratedField::Epoch => {
4691 if epoch__.is_some() {
4692 return Err(serde::de::Error::duplicate_field("epoch"));
4693 }
4694 epoch__ =
4695 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4696 ;
4697 }
4698 GeneratedField::TableId => {
4699 if table_id__.is_some() {
4700 return Err(serde::de::Error::duplicate_field("tableId"));
4701 }
4702 table_id__ =
4703 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4704 ;
4705 }
4706 }
4707 }
4708 Ok(GetVersionByEpochRequest {
4709 epoch: epoch__.unwrap_or_default(),
4710 table_id: table_id__.unwrap_or_default(),
4711 })
4712 }
4713 }
4714 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
4715 }
4716}
4717impl serde::Serialize for GetVersionByEpochResponse {
4718 #[allow(deprecated)]
4719 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4720 where
4721 S: serde::Serializer,
4722 {
4723 use serde::ser::SerializeStruct;
4724 let mut len = 0;
4725 if self.version.is_some() {
4726 len += 1;
4727 }
4728 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
4729 if let Some(v) = self.version.as_ref() {
4730 struct_ser.serialize_field("version", v)?;
4731 }
4732 struct_ser.end()
4733 }
4734}
4735impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
4736 #[allow(deprecated)]
4737 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4738 where
4739 D: serde::Deserializer<'de>,
4740 {
4741 const FIELDS: &[&str] = &[
4742 "version",
4743 ];
4744
4745 #[allow(clippy::enum_variant_names)]
4746 enum GeneratedField {
4747 Version,
4748 }
4749 impl<'de> serde::Deserialize<'de> for GeneratedField {
4750 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4751 where
4752 D: serde::Deserializer<'de>,
4753 {
4754 struct GeneratedVisitor;
4755
4756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4757 type Value = GeneratedField;
4758
4759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4760 write!(formatter, "expected one of: {:?}", &FIELDS)
4761 }
4762
4763 #[allow(unused_variables)]
4764 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4765 where
4766 E: serde::de::Error,
4767 {
4768 match value {
4769 "version" => Ok(GeneratedField::Version),
4770 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4771 }
4772 }
4773 }
4774 deserializer.deserialize_identifier(GeneratedVisitor)
4775 }
4776 }
4777 struct GeneratedVisitor;
4778 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4779 type Value = GetVersionByEpochResponse;
4780
4781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4782 formatter.write_str("struct hummock.GetVersionByEpochResponse")
4783 }
4784
4785 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
4786 where
4787 V: serde::de::MapAccess<'de>,
4788 {
4789 let mut version__ = None;
4790 while let Some(k) = map_.next_key()? {
4791 match k {
4792 GeneratedField::Version => {
4793 if version__.is_some() {
4794 return Err(serde::de::Error::duplicate_field("version"));
4795 }
4796 version__ = map_.next_value()?;
4797 }
4798 }
4799 }
4800 Ok(GetVersionByEpochResponse {
4801 version: version__,
4802 })
4803 }
4804 }
4805 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
4806 }
4807}
4808impl serde::Serialize for GroupConstruct {
4809 #[allow(deprecated)]
4810 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4811 where
4812 S: serde::Serializer,
4813 {
4814 use serde::ser::SerializeStruct;
4815 let mut len = 0;
4816 if self.group_config.is_some() {
4817 len += 1;
4818 }
4819 if self.parent_group_id != 0 {
4820 len += 1;
4821 }
4822 if !self.table_ids.is_empty() {
4823 len += 1;
4824 }
4825 if self.group_id != 0 {
4826 len += 1;
4827 }
4828 if self.new_sst_start_id != 0 {
4829 len += 1;
4830 }
4831 if self.version != 0 {
4832 len += 1;
4833 }
4834 if self.split_key.is_some() {
4835 len += 1;
4836 }
4837 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
4838 if let Some(v) = self.group_config.as_ref() {
4839 struct_ser.serialize_field("groupConfig", v)?;
4840 }
4841 if self.parent_group_id != 0 {
4842 #[allow(clippy::needless_borrow)]
4843 #[allow(clippy::needless_borrows_for_generic_args)]
4844 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
4845 }
4846 if !self.table_ids.is_empty() {
4847 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4848 }
4849 if self.group_id != 0 {
4850 #[allow(clippy::needless_borrow)]
4851 #[allow(clippy::needless_borrows_for_generic_args)]
4852 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
4853 }
4854 if self.new_sst_start_id != 0 {
4855 #[allow(clippy::needless_borrow)]
4856 #[allow(clippy::needless_borrows_for_generic_args)]
4857 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
4858 }
4859 if self.version != 0 {
4860 let v = CompatibilityVersion::try_from(self.version)
4861 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4862 struct_ser.serialize_field("version", &v)?;
4863 }
4864 if let Some(v) = self.split_key.as_ref() {
4865 #[allow(clippy::needless_borrow)]
4866 #[allow(clippy::needless_borrows_for_generic_args)]
4867 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
4868 }
4869 struct_ser.end()
4870 }
4871}
4872impl<'de> serde::Deserialize<'de> for GroupConstruct {
4873 #[allow(deprecated)]
4874 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4875 where
4876 D: serde::Deserializer<'de>,
4877 {
4878 const FIELDS: &[&str] = &[
4879 "group_config",
4880 "groupConfig",
4881 "parent_group_id",
4882 "parentGroupId",
4883 "table_ids",
4884 "tableIds",
4885 "group_id",
4886 "groupId",
4887 "new_sst_start_id",
4888 "newSstStartId",
4889 "version",
4890 "split_key",
4891 "splitKey",
4892 ];
4893
4894 #[allow(clippy::enum_variant_names)]
4895 enum GeneratedField {
4896 GroupConfig,
4897 ParentGroupId,
4898 TableIds,
4899 GroupId,
4900 NewSstStartId,
4901 Version,
4902 SplitKey,
4903 }
4904 impl<'de> serde::Deserialize<'de> for GeneratedField {
4905 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4906 where
4907 D: serde::Deserializer<'de>,
4908 {
4909 struct GeneratedVisitor;
4910
4911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4912 type Value = GeneratedField;
4913
4914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4915 write!(formatter, "expected one of: {:?}", &FIELDS)
4916 }
4917
4918 #[allow(unused_variables)]
4919 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4920 where
4921 E: serde::de::Error,
4922 {
4923 match value {
4924 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
4925 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
4926 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4927 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
4928 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
4929 "version" => Ok(GeneratedField::Version),
4930 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
4931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4932 }
4933 }
4934 }
4935 deserializer.deserialize_identifier(GeneratedVisitor)
4936 }
4937 }
4938 struct GeneratedVisitor;
4939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4940 type Value = GroupConstruct;
4941
4942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4943 formatter.write_str("struct hummock.GroupConstruct")
4944 }
4945
4946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
4947 where
4948 V: serde::de::MapAccess<'de>,
4949 {
4950 let mut group_config__ = None;
4951 let mut parent_group_id__ = None;
4952 let mut table_ids__ = None;
4953 let mut group_id__ = None;
4954 let mut new_sst_start_id__ = None;
4955 let mut version__ = None;
4956 let mut split_key__ = None;
4957 while let Some(k) = map_.next_key()? {
4958 match k {
4959 GeneratedField::GroupConfig => {
4960 if group_config__.is_some() {
4961 return Err(serde::de::Error::duplicate_field("groupConfig"));
4962 }
4963 group_config__ = map_.next_value()?;
4964 }
4965 GeneratedField::ParentGroupId => {
4966 if parent_group_id__.is_some() {
4967 return Err(serde::de::Error::duplicate_field("parentGroupId"));
4968 }
4969 parent_group_id__ =
4970 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4971 ;
4972 }
4973 GeneratedField::TableIds => {
4974 if table_ids__.is_some() {
4975 return Err(serde::de::Error::duplicate_field("tableIds"));
4976 }
4977 table_ids__ =
4978 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4979 .into_iter().map(|x| x.0).collect())
4980 ;
4981 }
4982 GeneratedField::GroupId => {
4983 if group_id__.is_some() {
4984 return Err(serde::de::Error::duplicate_field("groupId"));
4985 }
4986 group_id__ =
4987 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4988 ;
4989 }
4990 GeneratedField::NewSstStartId => {
4991 if new_sst_start_id__.is_some() {
4992 return Err(serde::de::Error::duplicate_field("newSstStartId"));
4993 }
4994 new_sst_start_id__ =
4995 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4996 ;
4997 }
4998 GeneratedField::Version => {
4999 if version__.is_some() {
5000 return Err(serde::de::Error::duplicate_field("version"));
5001 }
5002 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
5003 }
5004 GeneratedField::SplitKey => {
5005 if split_key__.is_some() {
5006 return Err(serde::de::Error::duplicate_field("splitKey"));
5007 }
5008 split_key__ =
5009 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
5010 ;
5011 }
5012 }
5013 }
5014 Ok(GroupConstruct {
5015 group_config: group_config__,
5016 parent_group_id: parent_group_id__.unwrap_or_default(),
5017 table_ids: table_ids__.unwrap_or_default(),
5018 group_id: group_id__.unwrap_or_default(),
5019 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
5020 version: version__.unwrap_or_default(),
5021 split_key: split_key__,
5022 })
5023 }
5024 }
5025 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
5026 }
5027}
5028impl serde::Serialize for GroupDelta {
5029 #[allow(deprecated)]
5030 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5031 where
5032 S: serde::Serializer,
5033 {
5034 use serde::ser::SerializeStruct;
5035 let mut len = 0;
5036 if self.delta_type.is_some() {
5037 len += 1;
5038 }
5039 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
5040 if let Some(v) = self.delta_type.as_ref() {
5041 match v {
5042 group_delta::DeltaType::IntraLevel(v) => {
5043 struct_ser.serialize_field("intraLevel", v)?;
5044 }
5045 group_delta::DeltaType::GroupConstruct(v) => {
5046 struct_ser.serialize_field("groupConstruct", v)?;
5047 }
5048 group_delta::DeltaType::GroupDestroy(v) => {
5049 struct_ser.serialize_field("groupDestroy", v)?;
5050 }
5051 group_delta::DeltaType::GroupMerge(v) => {
5052 struct_ser.serialize_field("groupMerge", v)?;
5053 }
5054 group_delta::DeltaType::NewL0SubLevel(v) => {
5055 struct_ser.serialize_field("newL0SubLevel", v)?;
5056 }
5057 }
5058 }
5059 struct_ser.end()
5060 }
5061}
5062impl<'de> serde::Deserialize<'de> for GroupDelta {
5063 #[allow(deprecated)]
5064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5065 where
5066 D: serde::Deserializer<'de>,
5067 {
5068 const FIELDS: &[&str] = &[
5069 "intra_level",
5070 "intraLevel",
5071 "group_construct",
5072 "groupConstruct",
5073 "group_destroy",
5074 "groupDestroy",
5075 "group_merge",
5076 "groupMerge",
5077 "new_l0_sub_level",
5078 "newL0SubLevel",
5079 ];
5080
5081 #[allow(clippy::enum_variant_names)]
5082 enum GeneratedField {
5083 IntraLevel,
5084 GroupConstruct,
5085 GroupDestroy,
5086 GroupMerge,
5087 NewL0SubLevel,
5088 }
5089 impl<'de> serde::Deserialize<'de> for GeneratedField {
5090 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5091 where
5092 D: serde::Deserializer<'de>,
5093 {
5094 struct GeneratedVisitor;
5095
5096 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5097 type Value = GeneratedField;
5098
5099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5100 write!(formatter, "expected one of: {:?}", &FIELDS)
5101 }
5102
5103 #[allow(unused_variables)]
5104 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5105 where
5106 E: serde::de::Error,
5107 {
5108 match value {
5109 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5110 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5111 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5112 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5113 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5114 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5115 }
5116 }
5117 }
5118 deserializer.deserialize_identifier(GeneratedVisitor)
5119 }
5120 }
5121 struct GeneratedVisitor;
5122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5123 type Value = GroupDelta;
5124
5125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5126 formatter.write_str("struct hummock.GroupDelta")
5127 }
5128
5129 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5130 where
5131 V: serde::de::MapAccess<'de>,
5132 {
5133 let mut delta_type__ = None;
5134 while let Some(k) = map_.next_key()? {
5135 match k {
5136 GeneratedField::IntraLevel => {
5137 if delta_type__.is_some() {
5138 return Err(serde::de::Error::duplicate_field("intraLevel"));
5139 }
5140 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5141;
5142 }
5143 GeneratedField::GroupConstruct => {
5144 if delta_type__.is_some() {
5145 return Err(serde::de::Error::duplicate_field("groupConstruct"));
5146 }
5147 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5148;
5149 }
5150 GeneratedField::GroupDestroy => {
5151 if delta_type__.is_some() {
5152 return Err(serde::de::Error::duplicate_field("groupDestroy"));
5153 }
5154 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5155;
5156 }
5157 GeneratedField::GroupMerge => {
5158 if delta_type__.is_some() {
5159 return Err(serde::de::Error::duplicate_field("groupMerge"));
5160 }
5161 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5162;
5163 }
5164 GeneratedField::NewL0SubLevel => {
5165 if delta_type__.is_some() {
5166 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5167 }
5168 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5169;
5170 }
5171 }
5172 }
5173 Ok(GroupDelta {
5174 delta_type: delta_type__,
5175 })
5176 }
5177 }
5178 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5179 }
5180}
5181impl serde::Serialize for GroupDestroy {
5182 #[allow(deprecated)]
5183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5184 where
5185 S: serde::Serializer,
5186 {
5187 use serde::ser::SerializeStruct;
5188 let len = 0;
5189 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5190 struct_ser.end()
5191 }
5192}
5193impl<'de> serde::Deserialize<'de> for GroupDestroy {
5194 #[allow(deprecated)]
5195 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5196 where
5197 D: serde::Deserializer<'de>,
5198 {
5199 const FIELDS: &[&str] = &[
5200 ];
5201
5202 #[allow(clippy::enum_variant_names)]
5203 enum GeneratedField {
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 Err(serde::de::Error::unknown_field(value, FIELDS))
5225 }
5226 }
5227 deserializer.deserialize_identifier(GeneratedVisitor)
5228 }
5229 }
5230 struct GeneratedVisitor;
5231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5232 type Value = GroupDestroy;
5233
5234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5235 formatter.write_str("struct hummock.GroupDestroy")
5236 }
5237
5238 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5239 where
5240 V: serde::de::MapAccess<'de>,
5241 {
5242 while map_.next_key::<GeneratedField>()?.is_some() {
5243 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5244 }
5245 Ok(GroupDestroy {
5246 })
5247 }
5248 }
5249 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5250 }
5251}
5252impl serde::Serialize for GroupMerge {
5253 #[allow(deprecated)]
5254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5255 where
5256 S: serde::Serializer,
5257 {
5258 use serde::ser::SerializeStruct;
5259 let mut len = 0;
5260 if self.left_group_id != 0 {
5261 len += 1;
5262 }
5263 if self.right_group_id != 0 {
5264 len += 1;
5265 }
5266 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5267 if self.left_group_id != 0 {
5268 #[allow(clippy::needless_borrow)]
5269 #[allow(clippy::needless_borrows_for_generic_args)]
5270 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5271 }
5272 if self.right_group_id != 0 {
5273 #[allow(clippy::needless_borrow)]
5274 #[allow(clippy::needless_borrows_for_generic_args)]
5275 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5276 }
5277 struct_ser.end()
5278 }
5279}
5280impl<'de> serde::Deserialize<'de> for GroupMerge {
5281 #[allow(deprecated)]
5282 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5283 where
5284 D: serde::Deserializer<'de>,
5285 {
5286 const FIELDS: &[&str] = &[
5287 "left_group_id",
5288 "leftGroupId",
5289 "right_group_id",
5290 "rightGroupId",
5291 ];
5292
5293 #[allow(clippy::enum_variant_names)]
5294 enum GeneratedField {
5295 LeftGroupId,
5296 RightGroupId,
5297 }
5298 impl<'de> serde::Deserialize<'de> for GeneratedField {
5299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5300 where
5301 D: serde::Deserializer<'de>,
5302 {
5303 struct GeneratedVisitor;
5304
5305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5306 type Value = GeneratedField;
5307
5308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5309 write!(formatter, "expected one of: {:?}", &FIELDS)
5310 }
5311
5312 #[allow(unused_variables)]
5313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5314 where
5315 E: serde::de::Error,
5316 {
5317 match value {
5318 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5319 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5321 }
5322 }
5323 }
5324 deserializer.deserialize_identifier(GeneratedVisitor)
5325 }
5326 }
5327 struct GeneratedVisitor;
5328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5329 type Value = GroupMerge;
5330
5331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5332 formatter.write_str("struct hummock.GroupMerge")
5333 }
5334
5335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5336 where
5337 V: serde::de::MapAccess<'de>,
5338 {
5339 let mut left_group_id__ = None;
5340 let mut right_group_id__ = None;
5341 while let Some(k) = map_.next_key()? {
5342 match k {
5343 GeneratedField::LeftGroupId => {
5344 if left_group_id__.is_some() {
5345 return Err(serde::de::Error::duplicate_field("leftGroupId"));
5346 }
5347 left_group_id__ =
5348 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5349 ;
5350 }
5351 GeneratedField::RightGroupId => {
5352 if right_group_id__.is_some() {
5353 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5354 }
5355 right_group_id__ =
5356 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5357 ;
5358 }
5359 }
5360 }
5361 Ok(GroupMerge {
5362 left_group_id: left_group_id__.unwrap_or_default(),
5363 right_group_id: right_group_id__.unwrap_or_default(),
5364 })
5365 }
5366 }
5367 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5368 }
5369}
5370impl serde::Serialize for HummockPinnedSnapshot {
5371 #[allow(deprecated)]
5372 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5373 where
5374 S: serde::Serializer,
5375 {
5376 use serde::ser::SerializeStruct;
5377 let mut len = 0;
5378 if self.context_id != 0 {
5379 len += 1;
5380 }
5381 if self.minimal_pinned_snapshot != 0 {
5382 len += 1;
5383 }
5384 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
5385 if self.context_id != 0 {
5386 struct_ser.serialize_field("contextId", &self.context_id)?;
5387 }
5388 if self.minimal_pinned_snapshot != 0 {
5389 #[allow(clippy::needless_borrow)]
5390 #[allow(clippy::needless_borrows_for_generic_args)]
5391 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
5392 }
5393 struct_ser.end()
5394 }
5395}
5396impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
5397 #[allow(deprecated)]
5398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5399 where
5400 D: serde::Deserializer<'de>,
5401 {
5402 const FIELDS: &[&str] = &[
5403 "context_id",
5404 "contextId",
5405 "minimal_pinned_snapshot",
5406 "minimalPinnedSnapshot",
5407 ];
5408
5409 #[allow(clippy::enum_variant_names)]
5410 enum GeneratedField {
5411 ContextId,
5412 MinimalPinnedSnapshot,
5413 }
5414 impl<'de> serde::Deserialize<'de> for GeneratedField {
5415 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5416 where
5417 D: serde::Deserializer<'de>,
5418 {
5419 struct GeneratedVisitor;
5420
5421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5422 type Value = GeneratedField;
5423
5424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5425 write!(formatter, "expected one of: {:?}", &FIELDS)
5426 }
5427
5428 #[allow(unused_variables)]
5429 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5430 where
5431 E: serde::de::Error,
5432 {
5433 match value {
5434 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5435 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
5436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5437 }
5438 }
5439 }
5440 deserializer.deserialize_identifier(GeneratedVisitor)
5441 }
5442 }
5443 struct GeneratedVisitor;
5444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5445 type Value = HummockPinnedSnapshot;
5446
5447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5448 formatter.write_str("struct hummock.HummockPinnedSnapshot")
5449 }
5450
5451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
5452 where
5453 V: serde::de::MapAccess<'de>,
5454 {
5455 let mut context_id__ = None;
5456 let mut minimal_pinned_snapshot__ = None;
5457 while let Some(k) = map_.next_key()? {
5458 match k {
5459 GeneratedField::ContextId => {
5460 if context_id__.is_some() {
5461 return Err(serde::de::Error::duplicate_field("contextId"));
5462 }
5463 context_id__ =
5464 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5465 ;
5466 }
5467 GeneratedField::MinimalPinnedSnapshot => {
5468 if minimal_pinned_snapshot__.is_some() {
5469 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
5470 }
5471 minimal_pinned_snapshot__ =
5472 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5473 ;
5474 }
5475 }
5476 }
5477 Ok(HummockPinnedSnapshot {
5478 context_id: context_id__.unwrap_or_default(),
5479 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
5480 })
5481 }
5482 }
5483 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
5484 }
5485}
5486impl serde::Serialize for HummockPinnedVersion {
5487 #[allow(deprecated)]
5488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5489 where
5490 S: serde::Serializer,
5491 {
5492 use serde::ser::SerializeStruct;
5493 let mut len = 0;
5494 if self.context_id != 0 {
5495 len += 1;
5496 }
5497 if self.min_pinned_id != 0 {
5498 len += 1;
5499 }
5500 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
5501 if self.context_id != 0 {
5502 struct_ser.serialize_field("contextId", &self.context_id)?;
5503 }
5504 if self.min_pinned_id != 0 {
5505 #[allow(clippy::needless_borrow)]
5506 #[allow(clippy::needless_borrows_for_generic_args)]
5507 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
5508 }
5509 struct_ser.end()
5510 }
5511}
5512impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
5513 #[allow(deprecated)]
5514 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5515 where
5516 D: serde::Deserializer<'de>,
5517 {
5518 const FIELDS: &[&str] = &[
5519 "context_id",
5520 "contextId",
5521 "min_pinned_id",
5522 "minPinnedId",
5523 ];
5524
5525 #[allow(clippy::enum_variant_names)]
5526 enum GeneratedField {
5527 ContextId,
5528 MinPinnedId,
5529 }
5530 impl<'de> serde::Deserialize<'de> for GeneratedField {
5531 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5532 where
5533 D: serde::Deserializer<'de>,
5534 {
5535 struct GeneratedVisitor;
5536
5537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5538 type Value = GeneratedField;
5539
5540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5541 write!(formatter, "expected one of: {:?}", &FIELDS)
5542 }
5543
5544 #[allow(unused_variables)]
5545 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5546 where
5547 E: serde::de::Error,
5548 {
5549 match value {
5550 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5551 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
5552 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5553 }
5554 }
5555 }
5556 deserializer.deserialize_identifier(GeneratedVisitor)
5557 }
5558 }
5559 struct GeneratedVisitor;
5560 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5561 type Value = HummockPinnedVersion;
5562
5563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5564 formatter.write_str("struct hummock.HummockPinnedVersion")
5565 }
5566
5567 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
5568 where
5569 V: serde::de::MapAccess<'de>,
5570 {
5571 let mut context_id__ = None;
5572 let mut min_pinned_id__ = None;
5573 while let Some(k) = map_.next_key()? {
5574 match k {
5575 GeneratedField::ContextId => {
5576 if context_id__.is_some() {
5577 return Err(serde::de::Error::duplicate_field("contextId"));
5578 }
5579 context_id__ =
5580 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5581 ;
5582 }
5583 GeneratedField::MinPinnedId => {
5584 if min_pinned_id__.is_some() {
5585 return Err(serde::de::Error::duplicate_field("minPinnedId"));
5586 }
5587 min_pinned_id__ =
5588 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5589 ;
5590 }
5591 }
5592 }
5593 Ok(HummockPinnedVersion {
5594 context_id: context_id__.unwrap_or_default(),
5595 min_pinned_id: min_pinned_id__.unwrap_or_default(),
5596 })
5597 }
5598 }
5599 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
5600 }
5601}
5602impl serde::Serialize for HummockVersion {
5603 #[allow(deprecated)]
5604 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5605 where
5606 S: serde::Serializer,
5607 {
5608 use serde::ser::SerializeStruct;
5609 let mut len = 0;
5610 if self.id != 0 {
5611 len += 1;
5612 }
5613 if !self.levels.is_empty() {
5614 len += 1;
5615 }
5616 if self.max_committed_epoch != 0 {
5617 len += 1;
5618 }
5619 if !self.table_watermarks.is_empty() {
5620 len += 1;
5621 }
5622 if !self.table_change_logs.is_empty() {
5623 len += 1;
5624 }
5625 if !self.state_table_info.is_empty() {
5626 len += 1;
5627 }
5628 if !self.vector_indexes.is_empty() {
5629 len += 1;
5630 }
5631 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
5632 if self.id != 0 {
5633 #[allow(clippy::needless_borrow)]
5634 #[allow(clippy::needless_borrows_for_generic_args)]
5635 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
5636 }
5637 if !self.levels.is_empty() {
5638 struct_ser.serialize_field("levels", &self.levels)?;
5639 }
5640 if self.max_committed_epoch != 0 {
5641 #[allow(clippy::needless_borrow)]
5642 #[allow(clippy::needless_borrows_for_generic_args)]
5643 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
5644 }
5645 if !self.table_watermarks.is_empty() {
5646 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
5647 }
5648 if !self.table_change_logs.is_empty() {
5649 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
5650 }
5651 if !self.state_table_info.is_empty() {
5652 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
5653 }
5654 if !self.vector_indexes.is_empty() {
5655 struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
5656 }
5657 struct_ser.end()
5658 }
5659}
5660impl<'de> serde::Deserialize<'de> for HummockVersion {
5661 #[allow(deprecated)]
5662 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5663 where
5664 D: serde::Deserializer<'de>,
5665 {
5666 const FIELDS: &[&str] = &[
5667 "id",
5668 "levels",
5669 "max_committed_epoch",
5670 "maxCommittedEpoch",
5671 "table_watermarks",
5672 "tableWatermarks",
5673 "table_change_logs",
5674 "tableChangeLogs",
5675 "state_table_info",
5676 "stateTableInfo",
5677 "vector_indexes",
5678 "vectorIndexes",
5679 ];
5680
5681 #[allow(clippy::enum_variant_names)]
5682 enum GeneratedField {
5683 Id,
5684 Levels,
5685 MaxCommittedEpoch,
5686 TableWatermarks,
5687 TableChangeLogs,
5688 StateTableInfo,
5689 VectorIndexes,
5690 }
5691 impl<'de> serde::Deserialize<'de> for GeneratedField {
5692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5693 where
5694 D: serde::Deserializer<'de>,
5695 {
5696 struct GeneratedVisitor;
5697
5698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5699 type Value = GeneratedField;
5700
5701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5702 write!(formatter, "expected one of: {:?}", &FIELDS)
5703 }
5704
5705 #[allow(unused_variables)]
5706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5707 where
5708 E: serde::de::Error,
5709 {
5710 match value {
5711 "id" => Ok(GeneratedField::Id),
5712 "levels" => Ok(GeneratedField::Levels),
5713 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
5714 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
5715 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
5716 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
5717 "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
5718 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5719 }
5720 }
5721 }
5722 deserializer.deserialize_identifier(GeneratedVisitor)
5723 }
5724 }
5725 struct GeneratedVisitor;
5726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5727 type Value = HummockVersion;
5728
5729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5730 formatter.write_str("struct hummock.HummockVersion")
5731 }
5732
5733 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
5734 where
5735 V: serde::de::MapAccess<'de>,
5736 {
5737 let mut id__ = None;
5738 let mut levels__ = None;
5739 let mut max_committed_epoch__ = None;
5740 let mut table_watermarks__ = None;
5741 let mut table_change_logs__ = None;
5742 let mut state_table_info__ = None;
5743 let mut vector_indexes__ = None;
5744 while let Some(k) = map_.next_key()? {
5745 match k {
5746 GeneratedField::Id => {
5747 if id__.is_some() {
5748 return Err(serde::de::Error::duplicate_field("id"));
5749 }
5750 id__ =
5751 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5752 ;
5753 }
5754 GeneratedField::Levels => {
5755 if levels__.is_some() {
5756 return Err(serde::de::Error::duplicate_field("levels"));
5757 }
5758 levels__ = Some(
5759 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
5760 .into_iter().map(|(k,v)| (k.0, v)).collect()
5761 );
5762 }
5763 GeneratedField::MaxCommittedEpoch => {
5764 if max_committed_epoch__.is_some() {
5765 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
5766 }
5767 max_committed_epoch__ =
5768 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5769 ;
5770 }
5771 GeneratedField::TableWatermarks => {
5772 if table_watermarks__.is_some() {
5773 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
5774 }
5775 table_watermarks__ = Some(
5776 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5777 .into_iter().map(|(k,v)| (k.0, v)).collect()
5778 );
5779 }
5780 GeneratedField::TableChangeLogs => {
5781 if table_change_logs__.is_some() {
5782 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
5783 }
5784 table_change_logs__ = Some(
5785 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5786 .into_iter().map(|(k,v)| (k.0, v)).collect()
5787 );
5788 }
5789 GeneratedField::StateTableInfo => {
5790 if state_table_info__.is_some() {
5791 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
5792 }
5793 state_table_info__ = Some(
5794 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5795 .into_iter().map(|(k,v)| (k.0, v)).collect()
5796 );
5797 }
5798 GeneratedField::VectorIndexes => {
5799 if vector_indexes__.is_some() {
5800 return Err(serde::de::Error::duplicate_field("vectorIndexes"));
5801 }
5802 vector_indexes__ = Some(
5803 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5804 .into_iter().map(|(k,v)| (k.0, v)).collect()
5805 );
5806 }
5807 }
5808 }
5809 Ok(HummockVersion {
5810 id: id__.unwrap_or_default(),
5811 levels: levels__.unwrap_or_default(),
5812 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
5813 table_watermarks: table_watermarks__.unwrap_or_default(),
5814 table_change_logs: table_change_logs__.unwrap_or_default(),
5815 state_table_info: state_table_info__.unwrap_or_default(),
5816 vector_indexes: vector_indexes__.unwrap_or_default(),
5817 })
5818 }
5819 }
5820 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
5821 }
5822}
5823impl serde::Serialize for hummock_version::Levels {
5824 #[allow(deprecated)]
5825 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5826 where
5827 S: serde::Serializer,
5828 {
5829 use serde::ser::SerializeStruct;
5830 let mut len = 0;
5831 if !self.levels.is_empty() {
5832 len += 1;
5833 }
5834 if self.l0.is_some() {
5835 len += 1;
5836 }
5837 if self.group_id != 0 {
5838 len += 1;
5839 }
5840 if self.parent_group_id != 0 {
5841 len += 1;
5842 }
5843 if !self.member_table_ids.is_empty() {
5844 len += 1;
5845 }
5846 if self.compaction_group_version_id != 0 {
5847 len += 1;
5848 }
5849 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
5850 if !self.levels.is_empty() {
5851 struct_ser.serialize_field("levels", &self.levels)?;
5852 }
5853 if let Some(v) = self.l0.as_ref() {
5854 struct_ser.serialize_field("l0", v)?;
5855 }
5856 if self.group_id != 0 {
5857 #[allow(clippy::needless_borrow)]
5858 #[allow(clippy::needless_borrows_for_generic_args)]
5859 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
5860 }
5861 if self.parent_group_id != 0 {
5862 #[allow(clippy::needless_borrow)]
5863 #[allow(clippy::needless_borrows_for_generic_args)]
5864 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
5865 }
5866 if !self.member_table_ids.is_empty() {
5867 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
5868 }
5869 if self.compaction_group_version_id != 0 {
5870 #[allow(clippy::needless_borrow)]
5871 #[allow(clippy::needless_borrows_for_generic_args)]
5872 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
5873 }
5874 struct_ser.end()
5875 }
5876}
5877impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
5878 #[allow(deprecated)]
5879 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5880 where
5881 D: serde::Deserializer<'de>,
5882 {
5883 const FIELDS: &[&str] = &[
5884 "levels",
5885 "l0",
5886 "group_id",
5887 "groupId",
5888 "parent_group_id",
5889 "parentGroupId",
5890 "member_table_ids",
5891 "memberTableIds",
5892 "compaction_group_version_id",
5893 "compactionGroupVersionId",
5894 ];
5895
5896 #[allow(clippy::enum_variant_names)]
5897 enum GeneratedField {
5898 Levels,
5899 L0,
5900 GroupId,
5901 ParentGroupId,
5902 MemberTableIds,
5903 CompactionGroupVersionId,
5904 }
5905 impl<'de> serde::Deserialize<'de> for GeneratedField {
5906 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5907 where
5908 D: serde::Deserializer<'de>,
5909 {
5910 struct GeneratedVisitor;
5911
5912 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5913 type Value = GeneratedField;
5914
5915 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5916 write!(formatter, "expected one of: {:?}", &FIELDS)
5917 }
5918
5919 #[allow(unused_variables)]
5920 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5921 where
5922 E: serde::de::Error,
5923 {
5924 match value {
5925 "levels" => Ok(GeneratedField::Levels),
5926 "l0" => Ok(GeneratedField::L0),
5927 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
5928 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
5929 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
5930 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
5931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5932 }
5933 }
5934 }
5935 deserializer.deserialize_identifier(GeneratedVisitor)
5936 }
5937 }
5938 struct GeneratedVisitor;
5939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5940 type Value = hummock_version::Levels;
5941
5942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5943 formatter.write_str("struct hummock.HummockVersion.Levels")
5944 }
5945
5946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
5947 where
5948 V: serde::de::MapAccess<'de>,
5949 {
5950 let mut levels__ = None;
5951 let mut l0__ = None;
5952 let mut group_id__ = None;
5953 let mut parent_group_id__ = None;
5954 let mut member_table_ids__ = None;
5955 let mut compaction_group_version_id__ = None;
5956 while let Some(k) = map_.next_key()? {
5957 match k {
5958 GeneratedField::Levels => {
5959 if levels__.is_some() {
5960 return Err(serde::de::Error::duplicate_field("levels"));
5961 }
5962 levels__ = Some(map_.next_value()?);
5963 }
5964 GeneratedField::L0 => {
5965 if l0__.is_some() {
5966 return Err(serde::de::Error::duplicate_field("l0"));
5967 }
5968 l0__ = map_.next_value()?;
5969 }
5970 GeneratedField::GroupId => {
5971 if group_id__.is_some() {
5972 return Err(serde::de::Error::duplicate_field("groupId"));
5973 }
5974 group_id__ =
5975 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5976 ;
5977 }
5978 GeneratedField::ParentGroupId => {
5979 if parent_group_id__.is_some() {
5980 return Err(serde::de::Error::duplicate_field("parentGroupId"));
5981 }
5982 parent_group_id__ =
5983 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5984 ;
5985 }
5986 GeneratedField::MemberTableIds => {
5987 if member_table_ids__.is_some() {
5988 return Err(serde::de::Error::duplicate_field("memberTableIds"));
5989 }
5990 member_table_ids__ =
5991 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5992 .into_iter().map(|x| x.0).collect())
5993 ;
5994 }
5995 GeneratedField::CompactionGroupVersionId => {
5996 if compaction_group_version_id__.is_some() {
5997 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
5998 }
5999 compaction_group_version_id__ =
6000 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6001 ;
6002 }
6003 }
6004 }
6005 Ok(hummock_version::Levels {
6006 levels: levels__.unwrap_or_default(),
6007 l0: l0__,
6008 group_id: group_id__.unwrap_or_default(),
6009 parent_group_id: parent_group_id__.unwrap_or_default(),
6010 member_table_ids: member_table_ids__.unwrap_or_default(),
6011 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
6012 })
6013 }
6014 }
6015 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
6016 }
6017}
6018impl serde::Serialize for HummockVersionArchive {
6019 #[allow(deprecated)]
6020 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6021 where
6022 S: serde::Serializer,
6023 {
6024 use serde::ser::SerializeStruct;
6025 let mut len = 0;
6026 if self.version.is_some() {
6027 len += 1;
6028 }
6029 if !self.version_deltas.is_empty() {
6030 len += 1;
6031 }
6032 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
6033 if let Some(v) = self.version.as_ref() {
6034 struct_ser.serialize_field("version", v)?;
6035 }
6036 if !self.version_deltas.is_empty() {
6037 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6038 }
6039 struct_ser.end()
6040 }
6041}
6042impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
6043 #[allow(deprecated)]
6044 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6045 where
6046 D: serde::Deserializer<'de>,
6047 {
6048 const FIELDS: &[&str] = &[
6049 "version",
6050 "version_deltas",
6051 "versionDeltas",
6052 ];
6053
6054 #[allow(clippy::enum_variant_names)]
6055 enum GeneratedField {
6056 Version,
6057 VersionDeltas,
6058 }
6059 impl<'de> serde::Deserialize<'de> for GeneratedField {
6060 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6061 where
6062 D: serde::Deserializer<'de>,
6063 {
6064 struct GeneratedVisitor;
6065
6066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6067 type Value = GeneratedField;
6068
6069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6070 write!(formatter, "expected one of: {:?}", &FIELDS)
6071 }
6072
6073 #[allow(unused_variables)]
6074 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6075 where
6076 E: serde::de::Error,
6077 {
6078 match value {
6079 "version" => Ok(GeneratedField::Version),
6080 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6081 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6082 }
6083 }
6084 }
6085 deserializer.deserialize_identifier(GeneratedVisitor)
6086 }
6087 }
6088 struct GeneratedVisitor;
6089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6090 type Value = HummockVersionArchive;
6091
6092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6093 formatter.write_str("struct hummock.HummockVersionArchive")
6094 }
6095
6096 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
6097 where
6098 V: serde::de::MapAccess<'de>,
6099 {
6100 let mut version__ = None;
6101 let mut version_deltas__ = None;
6102 while let Some(k) = map_.next_key()? {
6103 match k {
6104 GeneratedField::Version => {
6105 if version__.is_some() {
6106 return Err(serde::de::Error::duplicate_field("version"));
6107 }
6108 version__ = map_.next_value()?;
6109 }
6110 GeneratedField::VersionDeltas => {
6111 if version_deltas__.is_some() {
6112 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6113 }
6114 version_deltas__ = Some(map_.next_value()?);
6115 }
6116 }
6117 }
6118 Ok(HummockVersionArchive {
6119 version: version__,
6120 version_deltas: version_deltas__.unwrap_or_default(),
6121 })
6122 }
6123 }
6124 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
6125 }
6126}
6127impl serde::Serialize for HummockVersionCheckpoint {
6128 #[allow(deprecated)]
6129 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6130 where
6131 S: serde::Serializer,
6132 {
6133 use serde::ser::SerializeStruct;
6134 let mut len = 0;
6135 if self.version.is_some() {
6136 len += 1;
6137 }
6138 if !self.stale_objects.is_empty() {
6139 len += 1;
6140 }
6141 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
6142 if let Some(v) = self.version.as_ref() {
6143 struct_ser.serialize_field("version", v)?;
6144 }
6145 if !self.stale_objects.is_empty() {
6146 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
6147 }
6148 struct_ser.end()
6149 }
6150}
6151impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
6152 #[allow(deprecated)]
6153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6154 where
6155 D: serde::Deserializer<'de>,
6156 {
6157 const FIELDS: &[&str] = &[
6158 "version",
6159 "stale_objects",
6160 "staleObjects",
6161 ];
6162
6163 #[allow(clippy::enum_variant_names)]
6164 enum GeneratedField {
6165 Version,
6166 StaleObjects,
6167 }
6168 impl<'de> serde::Deserialize<'de> for GeneratedField {
6169 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6170 where
6171 D: serde::Deserializer<'de>,
6172 {
6173 struct GeneratedVisitor;
6174
6175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6176 type Value = GeneratedField;
6177
6178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6179 write!(formatter, "expected one of: {:?}", &FIELDS)
6180 }
6181
6182 #[allow(unused_variables)]
6183 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6184 where
6185 E: serde::de::Error,
6186 {
6187 match value {
6188 "version" => Ok(GeneratedField::Version),
6189 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
6190 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6191 }
6192 }
6193 }
6194 deserializer.deserialize_identifier(GeneratedVisitor)
6195 }
6196 }
6197 struct GeneratedVisitor;
6198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6199 type Value = HummockVersionCheckpoint;
6200
6201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6202 formatter.write_str("struct hummock.HummockVersionCheckpoint")
6203 }
6204
6205 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
6206 where
6207 V: serde::de::MapAccess<'de>,
6208 {
6209 let mut version__ = None;
6210 let mut stale_objects__ = None;
6211 while let Some(k) = map_.next_key()? {
6212 match k {
6213 GeneratedField::Version => {
6214 if version__.is_some() {
6215 return Err(serde::de::Error::duplicate_field("version"));
6216 }
6217 version__ = map_.next_value()?;
6218 }
6219 GeneratedField::StaleObjects => {
6220 if stale_objects__.is_some() {
6221 return Err(serde::de::Error::duplicate_field("staleObjects"));
6222 }
6223 stale_objects__ = Some(
6224 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6225 .into_iter().map(|(k,v)| (k.0, v)).collect()
6226 );
6227 }
6228 }
6229 }
6230 Ok(HummockVersionCheckpoint {
6231 version: version__,
6232 stale_objects: stale_objects__.unwrap_or_default(),
6233 })
6234 }
6235 }
6236 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
6237 }
6238}
6239impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
6240 #[allow(deprecated)]
6241 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6242 where
6243 S: serde::Serializer,
6244 {
6245 use serde::ser::SerializeStruct;
6246 let mut len = 0;
6247 if !self.id.is_empty() {
6248 len += 1;
6249 }
6250 if self.total_file_size != 0 {
6251 len += 1;
6252 }
6253 if !self.vector_files.is_empty() {
6254 len += 1;
6255 }
6256 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
6257 if !self.id.is_empty() {
6258 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
6259 }
6260 if self.total_file_size != 0 {
6261 #[allow(clippy::needless_borrow)]
6262 #[allow(clippy::needless_borrows_for_generic_args)]
6263 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
6264 }
6265 if !self.vector_files.is_empty() {
6266 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
6267 }
6268 struct_ser.end()
6269 }
6270}
6271impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
6272 #[allow(deprecated)]
6273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6274 where
6275 D: serde::Deserializer<'de>,
6276 {
6277 const FIELDS: &[&str] = &[
6278 "id",
6279 "total_file_size",
6280 "totalFileSize",
6281 "vector_files",
6282 "vectorFiles",
6283 ];
6284
6285 #[allow(clippy::enum_variant_names)]
6286 enum GeneratedField {
6287 Id,
6288 TotalFileSize,
6289 VectorFiles,
6290 }
6291 impl<'de> serde::Deserialize<'de> for GeneratedField {
6292 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6293 where
6294 D: serde::Deserializer<'de>,
6295 {
6296 struct GeneratedVisitor;
6297
6298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6299 type Value = GeneratedField;
6300
6301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6302 write!(formatter, "expected one of: {:?}", &FIELDS)
6303 }
6304
6305 #[allow(unused_variables)]
6306 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6307 where
6308 E: serde::de::Error,
6309 {
6310 match value {
6311 "id" => Ok(GeneratedField::Id),
6312 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
6313 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
6314 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6315 }
6316 }
6317 }
6318 deserializer.deserialize_identifier(GeneratedVisitor)
6319 }
6320 }
6321 struct GeneratedVisitor;
6322 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6323 type Value = hummock_version_checkpoint::StaleObjects;
6324
6325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6326 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
6327 }
6328
6329 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
6330 where
6331 V: serde::de::MapAccess<'de>,
6332 {
6333 let mut id__ = None;
6334 let mut total_file_size__ = None;
6335 let mut vector_files__ = None;
6336 while let Some(k) = map_.next_key()? {
6337 match k {
6338 GeneratedField::Id => {
6339 if id__.is_some() {
6340 return Err(serde::de::Error::duplicate_field("id"));
6341 }
6342 id__ =
6343 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6344 .into_iter().map(|x| x.0).collect())
6345 ;
6346 }
6347 GeneratedField::TotalFileSize => {
6348 if total_file_size__.is_some() {
6349 return Err(serde::de::Error::duplicate_field("totalFileSize"));
6350 }
6351 total_file_size__ =
6352 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6353 ;
6354 }
6355 GeneratedField::VectorFiles => {
6356 if vector_files__.is_some() {
6357 return Err(serde::de::Error::duplicate_field("vectorFiles"));
6358 }
6359 vector_files__ = Some(map_.next_value()?);
6360 }
6361 }
6362 }
6363 Ok(hummock_version_checkpoint::StaleObjects {
6364 id: id__.unwrap_or_default(),
6365 total_file_size: total_file_size__.unwrap_or_default(),
6366 vector_files: vector_files__.unwrap_or_default(),
6367 })
6368 }
6369 }
6370 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
6371 }
6372}
6373impl serde::Serialize for HummockVersionDelta {
6374 #[allow(deprecated)]
6375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6376 where
6377 S: serde::Serializer,
6378 {
6379 use serde::ser::SerializeStruct;
6380 let mut len = 0;
6381 if self.id != 0 {
6382 len += 1;
6383 }
6384 if self.prev_id != 0 {
6385 len += 1;
6386 }
6387 if !self.group_deltas.is_empty() {
6388 len += 1;
6389 }
6390 if self.max_committed_epoch != 0 {
6391 len += 1;
6392 }
6393 if self.trivial_move {
6394 len += 1;
6395 }
6396 if !self.new_table_watermarks.is_empty() {
6397 len += 1;
6398 }
6399 if !self.removed_table_ids.is_empty() {
6400 len += 1;
6401 }
6402 if !self.change_log_delta.is_empty() {
6403 len += 1;
6404 }
6405 if !self.state_table_info_delta.is_empty() {
6406 len += 1;
6407 }
6408 if !self.vector_index_delta.is_empty() {
6409 len += 1;
6410 }
6411 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
6412 if self.id != 0 {
6413 #[allow(clippy::needless_borrow)]
6414 #[allow(clippy::needless_borrows_for_generic_args)]
6415 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6416 }
6417 if self.prev_id != 0 {
6418 #[allow(clippy::needless_borrow)]
6419 #[allow(clippy::needless_borrows_for_generic_args)]
6420 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
6421 }
6422 if !self.group_deltas.is_empty() {
6423 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6424 }
6425 if self.max_committed_epoch != 0 {
6426 #[allow(clippy::needless_borrow)]
6427 #[allow(clippy::needless_borrows_for_generic_args)]
6428 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6429 }
6430 if self.trivial_move {
6431 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
6432 }
6433 if !self.new_table_watermarks.is_empty() {
6434 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
6435 }
6436 if !self.removed_table_ids.is_empty() {
6437 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
6438 }
6439 if !self.change_log_delta.is_empty() {
6440 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
6441 }
6442 if !self.state_table_info_delta.is_empty() {
6443 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
6444 }
6445 if !self.vector_index_delta.is_empty() {
6446 struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
6447 }
6448 struct_ser.end()
6449 }
6450}
6451impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
6452 #[allow(deprecated)]
6453 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6454 where
6455 D: serde::Deserializer<'de>,
6456 {
6457 const FIELDS: &[&str] = &[
6458 "id",
6459 "prev_id",
6460 "prevId",
6461 "group_deltas",
6462 "groupDeltas",
6463 "max_committed_epoch",
6464 "maxCommittedEpoch",
6465 "trivial_move",
6466 "trivialMove",
6467 "new_table_watermarks",
6468 "newTableWatermarks",
6469 "removed_table_ids",
6470 "removedTableIds",
6471 "change_log_delta",
6472 "changeLogDelta",
6473 "state_table_info_delta",
6474 "stateTableInfoDelta",
6475 "vector_index_delta",
6476 "vectorIndexDelta",
6477 ];
6478
6479 #[allow(clippy::enum_variant_names)]
6480 enum GeneratedField {
6481 Id,
6482 PrevId,
6483 GroupDeltas,
6484 MaxCommittedEpoch,
6485 TrivialMove,
6486 NewTableWatermarks,
6487 RemovedTableIds,
6488 ChangeLogDelta,
6489 StateTableInfoDelta,
6490 VectorIndexDelta,
6491 }
6492 impl<'de> serde::Deserialize<'de> for GeneratedField {
6493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6494 where
6495 D: serde::Deserializer<'de>,
6496 {
6497 struct GeneratedVisitor;
6498
6499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6500 type Value = GeneratedField;
6501
6502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6503 write!(formatter, "expected one of: {:?}", &FIELDS)
6504 }
6505
6506 #[allow(unused_variables)]
6507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6508 where
6509 E: serde::de::Error,
6510 {
6511 match value {
6512 "id" => Ok(GeneratedField::Id),
6513 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
6514 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6515 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6516 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
6517 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
6518 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
6519 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
6520 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
6521 "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
6522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6523 }
6524 }
6525 }
6526 deserializer.deserialize_identifier(GeneratedVisitor)
6527 }
6528 }
6529 struct GeneratedVisitor;
6530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6531 type Value = HummockVersionDelta;
6532
6533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6534 formatter.write_str("struct hummock.HummockVersionDelta")
6535 }
6536
6537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
6538 where
6539 V: serde::de::MapAccess<'de>,
6540 {
6541 let mut id__ = None;
6542 let mut prev_id__ = None;
6543 let mut group_deltas__ = None;
6544 let mut max_committed_epoch__ = None;
6545 let mut trivial_move__ = None;
6546 let mut new_table_watermarks__ = None;
6547 let mut removed_table_ids__ = None;
6548 let mut change_log_delta__ = None;
6549 let mut state_table_info_delta__ = None;
6550 let mut vector_index_delta__ = None;
6551 while let Some(k) = map_.next_key()? {
6552 match k {
6553 GeneratedField::Id => {
6554 if id__.is_some() {
6555 return Err(serde::de::Error::duplicate_field("id"));
6556 }
6557 id__ =
6558 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6559 ;
6560 }
6561 GeneratedField::PrevId => {
6562 if prev_id__.is_some() {
6563 return Err(serde::de::Error::duplicate_field("prevId"));
6564 }
6565 prev_id__ =
6566 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6567 ;
6568 }
6569 GeneratedField::GroupDeltas => {
6570 if group_deltas__.is_some() {
6571 return Err(serde::de::Error::duplicate_field("groupDeltas"));
6572 }
6573 group_deltas__ = Some(
6574 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6575 .into_iter().map(|(k,v)| (k.0, v)).collect()
6576 );
6577 }
6578 GeneratedField::MaxCommittedEpoch => {
6579 if max_committed_epoch__.is_some() {
6580 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
6581 }
6582 max_committed_epoch__ =
6583 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6584 ;
6585 }
6586 GeneratedField::TrivialMove => {
6587 if trivial_move__.is_some() {
6588 return Err(serde::de::Error::duplicate_field("trivialMove"));
6589 }
6590 trivial_move__ = Some(map_.next_value()?);
6591 }
6592 GeneratedField::NewTableWatermarks => {
6593 if new_table_watermarks__.is_some() {
6594 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
6595 }
6596 new_table_watermarks__ = Some(
6597 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6598 .into_iter().map(|(k,v)| (k.0, v)).collect()
6599 );
6600 }
6601 GeneratedField::RemovedTableIds => {
6602 if removed_table_ids__.is_some() {
6603 return Err(serde::de::Error::duplicate_field("removedTableIds"));
6604 }
6605 removed_table_ids__ =
6606 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6607 .into_iter().map(|x| x.0).collect())
6608 ;
6609 }
6610 GeneratedField::ChangeLogDelta => {
6611 if change_log_delta__.is_some() {
6612 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
6613 }
6614 change_log_delta__ = Some(
6615 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6616 .into_iter().map(|(k,v)| (k.0, v)).collect()
6617 );
6618 }
6619 GeneratedField::StateTableInfoDelta => {
6620 if state_table_info_delta__.is_some() {
6621 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
6622 }
6623 state_table_info_delta__ = Some(
6624 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6625 .into_iter().map(|(k,v)| (k.0, v)).collect()
6626 );
6627 }
6628 GeneratedField::VectorIndexDelta => {
6629 if vector_index_delta__.is_some() {
6630 return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
6631 }
6632 vector_index_delta__ = Some(
6633 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6634 .into_iter().map(|(k,v)| (k.0, v)).collect()
6635 );
6636 }
6637 }
6638 }
6639 Ok(HummockVersionDelta {
6640 id: id__.unwrap_or_default(),
6641 prev_id: prev_id__.unwrap_or_default(),
6642 group_deltas: group_deltas__.unwrap_or_default(),
6643 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
6644 trivial_move: trivial_move__.unwrap_or_default(),
6645 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
6646 removed_table_ids: removed_table_ids__.unwrap_or_default(),
6647 change_log_delta: change_log_delta__.unwrap_or_default(),
6648 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
6649 vector_index_delta: vector_index_delta__.unwrap_or_default(),
6650 })
6651 }
6652 }
6653 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
6654 }
6655}
6656impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
6657 #[allow(deprecated)]
6658 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6659 where
6660 S: serde::Serializer,
6661 {
6662 use serde::ser::SerializeStruct;
6663 let mut len = 0;
6664 if self.new_log.is_some() {
6665 len += 1;
6666 }
6667 if self.truncate_epoch != 0 {
6668 len += 1;
6669 }
6670 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
6671 if let Some(v) = self.new_log.as_ref() {
6672 struct_ser.serialize_field("newLog", v)?;
6673 }
6674 if self.truncate_epoch != 0 {
6675 #[allow(clippy::needless_borrow)]
6676 #[allow(clippy::needless_borrows_for_generic_args)]
6677 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
6678 }
6679 struct_ser.end()
6680 }
6681}
6682impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
6683 #[allow(deprecated)]
6684 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6685 where
6686 D: serde::Deserializer<'de>,
6687 {
6688 const FIELDS: &[&str] = &[
6689 "new_log",
6690 "newLog",
6691 "truncate_epoch",
6692 "truncateEpoch",
6693 ];
6694
6695 #[allow(clippy::enum_variant_names)]
6696 enum GeneratedField {
6697 NewLog,
6698 TruncateEpoch,
6699 }
6700 impl<'de> serde::Deserialize<'de> for GeneratedField {
6701 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6702 where
6703 D: serde::Deserializer<'de>,
6704 {
6705 struct GeneratedVisitor;
6706
6707 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6708 type Value = GeneratedField;
6709
6710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6711 write!(formatter, "expected one of: {:?}", &FIELDS)
6712 }
6713
6714 #[allow(unused_variables)]
6715 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6716 where
6717 E: serde::de::Error,
6718 {
6719 match value {
6720 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
6721 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
6722 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6723 }
6724 }
6725 }
6726 deserializer.deserialize_identifier(GeneratedVisitor)
6727 }
6728 }
6729 struct GeneratedVisitor;
6730 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6731 type Value = hummock_version_delta::ChangeLogDelta;
6732
6733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6734 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
6735 }
6736
6737 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
6738 where
6739 V: serde::de::MapAccess<'de>,
6740 {
6741 let mut new_log__ = None;
6742 let mut truncate_epoch__ = None;
6743 while let Some(k) = map_.next_key()? {
6744 match k {
6745 GeneratedField::NewLog => {
6746 if new_log__.is_some() {
6747 return Err(serde::de::Error::duplicate_field("newLog"));
6748 }
6749 new_log__ = map_.next_value()?;
6750 }
6751 GeneratedField::TruncateEpoch => {
6752 if truncate_epoch__.is_some() {
6753 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
6754 }
6755 truncate_epoch__ =
6756 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6757 ;
6758 }
6759 }
6760 }
6761 Ok(hummock_version_delta::ChangeLogDelta {
6762 new_log: new_log__,
6763 truncate_epoch: truncate_epoch__.unwrap_or_default(),
6764 })
6765 }
6766 }
6767 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
6768 }
6769}
6770impl serde::Serialize for hummock_version_delta::GroupDeltas {
6771 #[allow(deprecated)]
6772 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6773 where
6774 S: serde::Serializer,
6775 {
6776 use serde::ser::SerializeStruct;
6777 let mut len = 0;
6778 if !self.group_deltas.is_empty() {
6779 len += 1;
6780 }
6781 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
6782 if !self.group_deltas.is_empty() {
6783 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6784 }
6785 struct_ser.end()
6786 }
6787}
6788impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
6789 #[allow(deprecated)]
6790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6791 where
6792 D: serde::Deserializer<'de>,
6793 {
6794 const FIELDS: &[&str] = &[
6795 "group_deltas",
6796 "groupDeltas",
6797 ];
6798
6799 #[allow(clippy::enum_variant_names)]
6800 enum GeneratedField {
6801 GroupDeltas,
6802 }
6803 impl<'de> serde::Deserialize<'de> for GeneratedField {
6804 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6805 where
6806 D: serde::Deserializer<'de>,
6807 {
6808 struct GeneratedVisitor;
6809
6810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6811 type Value = GeneratedField;
6812
6813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6814 write!(formatter, "expected one of: {:?}", &FIELDS)
6815 }
6816
6817 #[allow(unused_variables)]
6818 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6819 where
6820 E: serde::de::Error,
6821 {
6822 match value {
6823 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6824 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6825 }
6826 }
6827 }
6828 deserializer.deserialize_identifier(GeneratedVisitor)
6829 }
6830 }
6831 struct GeneratedVisitor;
6832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6833 type Value = hummock_version_delta::GroupDeltas;
6834
6835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6836 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
6837 }
6838
6839 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
6840 where
6841 V: serde::de::MapAccess<'de>,
6842 {
6843 let mut group_deltas__ = None;
6844 while let Some(k) = map_.next_key()? {
6845 match k {
6846 GeneratedField::GroupDeltas => {
6847 if group_deltas__.is_some() {
6848 return Err(serde::de::Error::duplicate_field("groupDeltas"));
6849 }
6850 group_deltas__ = Some(map_.next_value()?);
6851 }
6852 }
6853 }
6854 Ok(hummock_version_delta::GroupDeltas {
6855 group_deltas: group_deltas__.unwrap_or_default(),
6856 })
6857 }
6858 }
6859 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
6860 }
6861}
6862impl serde::Serialize for HummockVersionDeltas {
6863 #[allow(deprecated)]
6864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6865 where
6866 S: serde::Serializer,
6867 {
6868 use serde::ser::SerializeStruct;
6869 let mut len = 0;
6870 if !self.version_deltas.is_empty() {
6871 len += 1;
6872 }
6873 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
6874 if !self.version_deltas.is_empty() {
6875 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6876 }
6877 struct_ser.end()
6878 }
6879}
6880impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
6881 #[allow(deprecated)]
6882 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6883 where
6884 D: serde::Deserializer<'de>,
6885 {
6886 const FIELDS: &[&str] = &[
6887 "version_deltas",
6888 "versionDeltas",
6889 ];
6890
6891 #[allow(clippy::enum_variant_names)]
6892 enum GeneratedField {
6893 VersionDeltas,
6894 }
6895 impl<'de> serde::Deserialize<'de> for GeneratedField {
6896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6897 where
6898 D: serde::Deserializer<'de>,
6899 {
6900 struct GeneratedVisitor;
6901
6902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6903 type Value = GeneratedField;
6904
6905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6906 write!(formatter, "expected one of: {:?}", &FIELDS)
6907 }
6908
6909 #[allow(unused_variables)]
6910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6911 where
6912 E: serde::de::Error,
6913 {
6914 match value {
6915 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6916 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6917 }
6918 }
6919 }
6920 deserializer.deserialize_identifier(GeneratedVisitor)
6921 }
6922 }
6923 struct GeneratedVisitor;
6924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6925 type Value = HummockVersionDeltas;
6926
6927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6928 formatter.write_str("struct hummock.HummockVersionDeltas")
6929 }
6930
6931 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
6932 where
6933 V: serde::de::MapAccess<'de>,
6934 {
6935 let mut version_deltas__ = None;
6936 while let Some(k) = map_.next_key()? {
6937 match k {
6938 GeneratedField::VersionDeltas => {
6939 if version_deltas__.is_some() {
6940 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6941 }
6942 version_deltas__ = Some(map_.next_value()?);
6943 }
6944 }
6945 }
6946 Ok(HummockVersionDeltas {
6947 version_deltas: version_deltas__.unwrap_or_default(),
6948 })
6949 }
6950 }
6951 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
6952 }
6953}
6954impl serde::Serialize for HummockVersionStats {
6955 #[allow(deprecated)]
6956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6957 where
6958 S: serde::Serializer,
6959 {
6960 use serde::ser::SerializeStruct;
6961 let mut len = 0;
6962 if self.hummock_version_id != 0 {
6963 len += 1;
6964 }
6965 if !self.table_stats.is_empty() {
6966 len += 1;
6967 }
6968 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
6969 if self.hummock_version_id != 0 {
6970 #[allow(clippy::needless_borrow)]
6971 #[allow(clippy::needless_borrows_for_generic_args)]
6972 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
6973 }
6974 if !self.table_stats.is_empty() {
6975 struct_ser.serialize_field("tableStats", &self.table_stats)?;
6976 }
6977 struct_ser.end()
6978 }
6979}
6980impl<'de> serde::Deserialize<'de> for HummockVersionStats {
6981 #[allow(deprecated)]
6982 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6983 where
6984 D: serde::Deserializer<'de>,
6985 {
6986 const FIELDS: &[&str] = &[
6987 "hummock_version_id",
6988 "hummockVersionId",
6989 "table_stats",
6990 "tableStats",
6991 ];
6992
6993 #[allow(clippy::enum_variant_names)]
6994 enum GeneratedField {
6995 HummockVersionId,
6996 TableStats,
6997 }
6998 impl<'de> serde::Deserialize<'de> for GeneratedField {
6999 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7000 where
7001 D: serde::Deserializer<'de>,
7002 {
7003 struct GeneratedVisitor;
7004
7005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7006 type Value = GeneratedField;
7007
7008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7009 write!(formatter, "expected one of: {:?}", &FIELDS)
7010 }
7011
7012 #[allow(unused_variables)]
7013 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7014 where
7015 E: serde::de::Error,
7016 {
7017 match value {
7018 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
7019 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
7020 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7021 }
7022 }
7023 }
7024 deserializer.deserialize_identifier(GeneratedVisitor)
7025 }
7026 }
7027 struct GeneratedVisitor;
7028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7029 type Value = HummockVersionStats;
7030
7031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7032 formatter.write_str("struct hummock.HummockVersionStats")
7033 }
7034
7035 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
7036 where
7037 V: serde::de::MapAccess<'de>,
7038 {
7039 let mut hummock_version_id__ = None;
7040 let mut table_stats__ = None;
7041 while let Some(k) = map_.next_key()? {
7042 match k {
7043 GeneratedField::HummockVersionId => {
7044 if hummock_version_id__.is_some() {
7045 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
7046 }
7047 hummock_version_id__ =
7048 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7049 ;
7050 }
7051 GeneratedField::TableStats => {
7052 if table_stats__.is_some() {
7053 return Err(serde::de::Error::duplicate_field("tableStats"));
7054 }
7055 table_stats__ = Some(
7056 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7057 .into_iter().map(|(k,v)| (k.0, v)).collect()
7058 );
7059 }
7060 }
7061 }
7062 Ok(HummockVersionStats {
7063 hummock_version_id: hummock_version_id__.unwrap_or_default(),
7064 table_stats: table_stats__.unwrap_or_default(),
7065 })
7066 }
7067 }
7068 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
7069 }
7070}
7071impl serde::Serialize for InitMetadataForReplayRequest {
7072 #[allow(deprecated)]
7073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7074 where
7075 S: serde::Serializer,
7076 {
7077 use serde::ser::SerializeStruct;
7078 let mut len = 0;
7079 if !self.tables.is_empty() {
7080 len += 1;
7081 }
7082 if !self.compaction_groups.is_empty() {
7083 len += 1;
7084 }
7085 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
7086 if !self.tables.is_empty() {
7087 struct_ser.serialize_field("tables", &self.tables)?;
7088 }
7089 if !self.compaction_groups.is_empty() {
7090 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
7091 }
7092 struct_ser.end()
7093 }
7094}
7095impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
7096 #[allow(deprecated)]
7097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7098 where
7099 D: serde::Deserializer<'de>,
7100 {
7101 const FIELDS: &[&str] = &[
7102 "tables",
7103 "compaction_groups",
7104 "compactionGroups",
7105 ];
7106
7107 #[allow(clippy::enum_variant_names)]
7108 enum GeneratedField {
7109 Tables,
7110 CompactionGroups,
7111 }
7112 impl<'de> serde::Deserialize<'de> for GeneratedField {
7113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7114 where
7115 D: serde::Deserializer<'de>,
7116 {
7117 struct GeneratedVisitor;
7118
7119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7120 type Value = GeneratedField;
7121
7122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7123 write!(formatter, "expected one of: {:?}", &FIELDS)
7124 }
7125
7126 #[allow(unused_variables)]
7127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7128 where
7129 E: serde::de::Error,
7130 {
7131 match value {
7132 "tables" => Ok(GeneratedField::Tables),
7133 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
7134 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7135 }
7136 }
7137 }
7138 deserializer.deserialize_identifier(GeneratedVisitor)
7139 }
7140 }
7141 struct GeneratedVisitor;
7142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7143 type Value = InitMetadataForReplayRequest;
7144
7145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7146 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
7147 }
7148
7149 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
7150 where
7151 V: serde::de::MapAccess<'de>,
7152 {
7153 let mut tables__ = None;
7154 let mut compaction_groups__ = None;
7155 while let Some(k) = map_.next_key()? {
7156 match k {
7157 GeneratedField::Tables => {
7158 if tables__.is_some() {
7159 return Err(serde::de::Error::duplicate_field("tables"));
7160 }
7161 tables__ = Some(map_.next_value()?);
7162 }
7163 GeneratedField::CompactionGroups => {
7164 if compaction_groups__.is_some() {
7165 return Err(serde::de::Error::duplicate_field("compactionGroups"));
7166 }
7167 compaction_groups__ = Some(map_.next_value()?);
7168 }
7169 }
7170 }
7171 Ok(InitMetadataForReplayRequest {
7172 tables: tables__.unwrap_or_default(),
7173 compaction_groups: compaction_groups__.unwrap_or_default(),
7174 })
7175 }
7176 }
7177 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
7178 }
7179}
7180impl serde::Serialize for InitMetadataForReplayResponse {
7181 #[allow(deprecated)]
7182 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7183 where
7184 S: serde::Serializer,
7185 {
7186 use serde::ser::SerializeStruct;
7187 let len = 0;
7188 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
7189 struct_ser.end()
7190 }
7191}
7192impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
7193 #[allow(deprecated)]
7194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7195 where
7196 D: serde::Deserializer<'de>,
7197 {
7198 const FIELDS: &[&str] = &[
7199 ];
7200
7201 #[allow(clippy::enum_variant_names)]
7202 enum GeneratedField {
7203 }
7204 impl<'de> serde::Deserialize<'de> for GeneratedField {
7205 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7206 where
7207 D: serde::Deserializer<'de>,
7208 {
7209 struct GeneratedVisitor;
7210
7211 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7212 type Value = GeneratedField;
7213
7214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7215 write!(formatter, "expected one of: {:?}", &FIELDS)
7216 }
7217
7218 #[allow(unused_variables)]
7219 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7220 where
7221 E: serde::de::Error,
7222 {
7223 Err(serde::de::Error::unknown_field(value, FIELDS))
7224 }
7225 }
7226 deserializer.deserialize_identifier(GeneratedVisitor)
7227 }
7228 }
7229 struct GeneratedVisitor;
7230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7231 type Value = InitMetadataForReplayResponse;
7232
7233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7234 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
7235 }
7236
7237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
7238 where
7239 V: serde::de::MapAccess<'de>,
7240 {
7241 while map_.next_key::<GeneratedField>()?.is_some() {
7242 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7243 }
7244 Ok(InitMetadataForReplayResponse {
7245 })
7246 }
7247 }
7248 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
7249 }
7250}
7251impl serde::Serialize for InputLevel {
7252 #[allow(deprecated)]
7253 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7254 where
7255 S: serde::Serializer,
7256 {
7257 use serde::ser::SerializeStruct;
7258 let mut len = 0;
7259 if self.level_idx != 0 {
7260 len += 1;
7261 }
7262 if self.level_type != 0 {
7263 len += 1;
7264 }
7265 if !self.table_infos.is_empty() {
7266 len += 1;
7267 }
7268 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
7269 if self.level_idx != 0 {
7270 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7271 }
7272 if self.level_type != 0 {
7273 let v = LevelType::try_from(self.level_type)
7274 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7275 struct_ser.serialize_field("levelType", &v)?;
7276 }
7277 if !self.table_infos.is_empty() {
7278 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7279 }
7280 struct_ser.end()
7281 }
7282}
7283impl<'de> serde::Deserialize<'de> for InputLevel {
7284 #[allow(deprecated)]
7285 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7286 where
7287 D: serde::Deserializer<'de>,
7288 {
7289 const FIELDS: &[&str] = &[
7290 "level_idx",
7291 "levelIdx",
7292 "level_type",
7293 "levelType",
7294 "table_infos",
7295 "tableInfos",
7296 ];
7297
7298 #[allow(clippy::enum_variant_names)]
7299 enum GeneratedField {
7300 LevelIdx,
7301 LevelType,
7302 TableInfos,
7303 }
7304 impl<'de> serde::Deserialize<'de> for GeneratedField {
7305 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7306 where
7307 D: serde::Deserializer<'de>,
7308 {
7309 struct GeneratedVisitor;
7310
7311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7312 type Value = GeneratedField;
7313
7314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7315 write!(formatter, "expected one of: {:?}", &FIELDS)
7316 }
7317
7318 #[allow(unused_variables)]
7319 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7320 where
7321 E: serde::de::Error,
7322 {
7323 match value {
7324 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7325 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
7326 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
7327 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7328 }
7329 }
7330 }
7331 deserializer.deserialize_identifier(GeneratedVisitor)
7332 }
7333 }
7334 struct GeneratedVisitor;
7335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7336 type Value = InputLevel;
7337
7338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7339 formatter.write_str("struct hummock.InputLevel")
7340 }
7341
7342 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
7343 where
7344 V: serde::de::MapAccess<'de>,
7345 {
7346 let mut level_idx__ = None;
7347 let mut level_type__ = None;
7348 let mut table_infos__ = None;
7349 while let Some(k) = map_.next_key()? {
7350 match k {
7351 GeneratedField::LevelIdx => {
7352 if level_idx__.is_some() {
7353 return Err(serde::de::Error::duplicate_field("levelIdx"));
7354 }
7355 level_idx__ =
7356 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7357 ;
7358 }
7359 GeneratedField::LevelType => {
7360 if level_type__.is_some() {
7361 return Err(serde::de::Error::duplicate_field("levelType"));
7362 }
7363 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
7364 }
7365 GeneratedField::TableInfos => {
7366 if table_infos__.is_some() {
7367 return Err(serde::de::Error::duplicate_field("tableInfos"));
7368 }
7369 table_infos__ = Some(map_.next_value()?);
7370 }
7371 }
7372 }
7373 Ok(InputLevel {
7374 level_idx: level_idx__.unwrap_or_default(),
7375 level_type: level_type__.unwrap_or_default(),
7376 table_infos: table_infos__.unwrap_or_default(),
7377 })
7378 }
7379 }
7380 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
7381 }
7382}
7383impl serde::Serialize for IntraLevelDelta {
7384 #[allow(deprecated)]
7385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7386 where
7387 S: serde::Serializer,
7388 {
7389 use serde::ser::SerializeStruct;
7390 let mut len = 0;
7391 if self.level_idx != 0 {
7392 len += 1;
7393 }
7394 if self.l0_sub_level_id != 0 {
7395 len += 1;
7396 }
7397 if !self.removed_table_ids.is_empty() {
7398 len += 1;
7399 }
7400 if !self.inserted_table_infos.is_empty() {
7401 len += 1;
7402 }
7403 if self.vnode_partition_count != 0 {
7404 len += 1;
7405 }
7406 if self.compaction_group_version_id != 0 {
7407 len += 1;
7408 }
7409 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
7410 if self.level_idx != 0 {
7411 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7412 }
7413 if self.l0_sub_level_id != 0 {
7414 #[allow(clippy::needless_borrow)]
7415 #[allow(clippy::needless_borrows_for_generic_args)]
7416 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
7417 }
7418 if !self.removed_table_ids.is_empty() {
7419 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7420 }
7421 if !self.inserted_table_infos.is_empty() {
7422 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
7423 }
7424 if self.vnode_partition_count != 0 {
7425 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7426 }
7427 if self.compaction_group_version_id != 0 {
7428 #[allow(clippy::needless_borrow)]
7429 #[allow(clippy::needless_borrows_for_generic_args)]
7430 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
7431 }
7432 struct_ser.end()
7433 }
7434}
7435impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
7436 #[allow(deprecated)]
7437 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7438 where
7439 D: serde::Deserializer<'de>,
7440 {
7441 const FIELDS: &[&str] = &[
7442 "level_idx",
7443 "levelIdx",
7444 "l0_sub_level_id",
7445 "l0SubLevelId",
7446 "removed_table_ids",
7447 "removedTableIds",
7448 "inserted_table_infos",
7449 "insertedTableInfos",
7450 "vnode_partition_count",
7451 "vnodePartitionCount",
7452 "compaction_group_version_id",
7453 "compactionGroupVersionId",
7454 ];
7455
7456 #[allow(clippy::enum_variant_names)]
7457 enum GeneratedField {
7458 LevelIdx,
7459 L0SubLevelId,
7460 RemovedTableIds,
7461 InsertedTableInfos,
7462 VnodePartitionCount,
7463 CompactionGroupVersionId,
7464 }
7465 impl<'de> serde::Deserialize<'de> for GeneratedField {
7466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7467 where
7468 D: serde::Deserializer<'de>,
7469 {
7470 struct GeneratedVisitor;
7471
7472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7473 type Value = GeneratedField;
7474
7475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7476 write!(formatter, "expected one of: {:?}", &FIELDS)
7477 }
7478
7479 #[allow(unused_variables)]
7480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7481 where
7482 E: serde::de::Error,
7483 {
7484 match value {
7485 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7486 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
7487 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7488 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
7489 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7490 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
7491 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7492 }
7493 }
7494 }
7495 deserializer.deserialize_identifier(GeneratedVisitor)
7496 }
7497 }
7498 struct GeneratedVisitor;
7499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7500 type Value = IntraLevelDelta;
7501
7502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7503 formatter.write_str("struct hummock.IntraLevelDelta")
7504 }
7505
7506 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
7507 where
7508 V: serde::de::MapAccess<'de>,
7509 {
7510 let mut level_idx__ = None;
7511 let mut l0_sub_level_id__ = None;
7512 let mut removed_table_ids__ = None;
7513 let mut inserted_table_infos__ = None;
7514 let mut vnode_partition_count__ = None;
7515 let mut compaction_group_version_id__ = None;
7516 while let Some(k) = map_.next_key()? {
7517 match k {
7518 GeneratedField::LevelIdx => {
7519 if level_idx__.is_some() {
7520 return Err(serde::de::Error::duplicate_field("levelIdx"));
7521 }
7522 level_idx__ =
7523 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7524 ;
7525 }
7526 GeneratedField::L0SubLevelId => {
7527 if l0_sub_level_id__.is_some() {
7528 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
7529 }
7530 l0_sub_level_id__ =
7531 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7532 ;
7533 }
7534 GeneratedField::RemovedTableIds => {
7535 if removed_table_ids__.is_some() {
7536 return Err(serde::de::Error::duplicate_field("removedTableIds"));
7537 }
7538 removed_table_ids__ =
7539 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7540 .into_iter().map(|x| x.0).collect())
7541 ;
7542 }
7543 GeneratedField::InsertedTableInfos => {
7544 if inserted_table_infos__.is_some() {
7545 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
7546 }
7547 inserted_table_infos__ = Some(map_.next_value()?);
7548 }
7549 GeneratedField::VnodePartitionCount => {
7550 if vnode_partition_count__.is_some() {
7551 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7552 }
7553 vnode_partition_count__ =
7554 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7555 ;
7556 }
7557 GeneratedField::CompactionGroupVersionId => {
7558 if compaction_group_version_id__.is_some() {
7559 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
7560 }
7561 compaction_group_version_id__ =
7562 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7563 ;
7564 }
7565 }
7566 }
7567 Ok(IntraLevelDelta {
7568 level_idx: level_idx__.unwrap_or_default(),
7569 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
7570 removed_table_ids: removed_table_ids__.unwrap_or_default(),
7571 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
7572 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7573 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
7574 })
7575 }
7576 }
7577 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
7578 }
7579}
7580impl serde::Serialize for KeyRange {
7581 #[allow(deprecated)]
7582 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7583 where
7584 S: serde::Serializer,
7585 {
7586 use serde::ser::SerializeStruct;
7587 let mut len = 0;
7588 if !self.left.is_empty() {
7589 len += 1;
7590 }
7591 if !self.right.is_empty() {
7592 len += 1;
7593 }
7594 if self.right_exclusive {
7595 len += 1;
7596 }
7597 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
7598 if !self.left.is_empty() {
7599 #[allow(clippy::needless_borrow)]
7600 #[allow(clippy::needless_borrows_for_generic_args)]
7601 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
7602 }
7603 if !self.right.is_empty() {
7604 #[allow(clippy::needless_borrow)]
7605 #[allow(clippy::needless_borrows_for_generic_args)]
7606 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
7607 }
7608 if self.right_exclusive {
7609 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
7610 }
7611 struct_ser.end()
7612 }
7613}
7614impl<'de> serde::Deserialize<'de> for KeyRange {
7615 #[allow(deprecated)]
7616 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7617 where
7618 D: serde::Deserializer<'de>,
7619 {
7620 const FIELDS: &[&str] = &[
7621 "left",
7622 "right",
7623 "right_exclusive",
7624 "rightExclusive",
7625 ];
7626
7627 #[allow(clippy::enum_variant_names)]
7628 enum GeneratedField {
7629 Left,
7630 Right,
7631 RightExclusive,
7632 }
7633 impl<'de> serde::Deserialize<'de> for GeneratedField {
7634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7635 where
7636 D: serde::Deserializer<'de>,
7637 {
7638 struct GeneratedVisitor;
7639
7640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7641 type Value = GeneratedField;
7642
7643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7644 write!(formatter, "expected one of: {:?}", &FIELDS)
7645 }
7646
7647 #[allow(unused_variables)]
7648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7649 where
7650 E: serde::de::Error,
7651 {
7652 match value {
7653 "left" => Ok(GeneratedField::Left),
7654 "right" => Ok(GeneratedField::Right),
7655 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
7656 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7657 }
7658 }
7659 }
7660 deserializer.deserialize_identifier(GeneratedVisitor)
7661 }
7662 }
7663 struct GeneratedVisitor;
7664 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7665 type Value = KeyRange;
7666
7667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7668 formatter.write_str("struct hummock.KeyRange")
7669 }
7670
7671 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
7672 where
7673 V: serde::de::MapAccess<'de>,
7674 {
7675 let mut left__ = None;
7676 let mut right__ = None;
7677 let mut right_exclusive__ = None;
7678 while let Some(k) = map_.next_key()? {
7679 match k {
7680 GeneratedField::Left => {
7681 if left__.is_some() {
7682 return Err(serde::de::Error::duplicate_field("left"));
7683 }
7684 left__ =
7685 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7686 ;
7687 }
7688 GeneratedField::Right => {
7689 if right__.is_some() {
7690 return Err(serde::de::Error::duplicate_field("right"));
7691 }
7692 right__ =
7693 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7694 ;
7695 }
7696 GeneratedField::RightExclusive => {
7697 if right_exclusive__.is_some() {
7698 return Err(serde::de::Error::duplicate_field("rightExclusive"));
7699 }
7700 right_exclusive__ = Some(map_.next_value()?);
7701 }
7702 }
7703 }
7704 Ok(KeyRange {
7705 left: left__.unwrap_or_default(),
7706 right: right__.unwrap_or_default(),
7707 right_exclusive: right_exclusive__.unwrap_or_default(),
7708 })
7709 }
7710 }
7711 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
7712 }
7713}
7714impl serde::Serialize for Level {
7715 #[allow(deprecated)]
7716 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7717 where
7718 S: serde::Serializer,
7719 {
7720 use serde::ser::SerializeStruct;
7721 let mut len = 0;
7722 if self.level_idx != 0 {
7723 len += 1;
7724 }
7725 if self.level_type != 0 {
7726 len += 1;
7727 }
7728 if !self.table_infos.is_empty() {
7729 len += 1;
7730 }
7731 if self.total_file_size != 0 {
7732 len += 1;
7733 }
7734 if self.sub_level_id != 0 {
7735 len += 1;
7736 }
7737 if self.uncompressed_file_size != 0 {
7738 len += 1;
7739 }
7740 if self.vnode_partition_count != 0 {
7741 len += 1;
7742 }
7743 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
7744 if self.level_idx != 0 {
7745 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7746 }
7747 if self.level_type != 0 {
7748 let v = LevelType::try_from(self.level_type)
7749 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7750 struct_ser.serialize_field("levelType", &v)?;
7751 }
7752 if !self.table_infos.is_empty() {
7753 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7754 }
7755 if self.total_file_size != 0 {
7756 #[allow(clippy::needless_borrow)]
7757 #[allow(clippy::needless_borrows_for_generic_args)]
7758 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7759 }
7760 if self.sub_level_id != 0 {
7761 #[allow(clippy::needless_borrow)]
7762 #[allow(clippy::needless_borrows_for_generic_args)]
7763 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
7764 }
7765 if self.uncompressed_file_size != 0 {
7766 #[allow(clippy::needless_borrow)]
7767 #[allow(clippy::needless_borrows_for_generic_args)]
7768 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
7769 }
7770 if self.vnode_partition_count != 0 {
7771 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7772 }
7773 struct_ser.end()
7774 }
7775}
7776impl<'de> serde::Deserialize<'de> for Level {
7777 #[allow(deprecated)]
7778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7779 where
7780 D: serde::Deserializer<'de>,
7781 {
7782 const FIELDS: &[&str] = &[
7783 "level_idx",
7784 "levelIdx",
7785 "level_type",
7786 "levelType",
7787 "table_infos",
7788 "tableInfos",
7789 "total_file_size",
7790 "totalFileSize",
7791 "sub_level_id",
7792 "subLevelId",
7793 "uncompressed_file_size",
7794 "uncompressedFileSize",
7795 "vnode_partition_count",
7796 "vnodePartitionCount",
7797 ];
7798
7799 #[allow(clippy::enum_variant_names)]
7800 enum GeneratedField {
7801 LevelIdx,
7802 LevelType,
7803 TableInfos,
7804 TotalFileSize,
7805 SubLevelId,
7806 UncompressedFileSize,
7807 VnodePartitionCount,
7808 }
7809 impl<'de> serde::Deserialize<'de> for GeneratedField {
7810 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7811 where
7812 D: serde::Deserializer<'de>,
7813 {
7814 struct GeneratedVisitor;
7815
7816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7817 type Value = GeneratedField;
7818
7819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7820 write!(formatter, "expected one of: {:?}", &FIELDS)
7821 }
7822
7823 #[allow(unused_variables)]
7824 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7825 where
7826 E: serde::de::Error,
7827 {
7828 match value {
7829 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7830 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
7831 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
7832 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7833 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
7834 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
7835 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7836 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7837 }
7838 }
7839 }
7840 deserializer.deserialize_identifier(GeneratedVisitor)
7841 }
7842 }
7843 struct GeneratedVisitor;
7844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7845 type Value = Level;
7846
7847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7848 formatter.write_str("struct hummock.Level")
7849 }
7850
7851 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
7852 where
7853 V: serde::de::MapAccess<'de>,
7854 {
7855 let mut level_idx__ = None;
7856 let mut level_type__ = None;
7857 let mut table_infos__ = None;
7858 let mut total_file_size__ = None;
7859 let mut sub_level_id__ = None;
7860 let mut uncompressed_file_size__ = None;
7861 let mut vnode_partition_count__ = None;
7862 while let Some(k) = map_.next_key()? {
7863 match k {
7864 GeneratedField::LevelIdx => {
7865 if level_idx__.is_some() {
7866 return Err(serde::de::Error::duplicate_field("levelIdx"));
7867 }
7868 level_idx__ =
7869 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7870 ;
7871 }
7872 GeneratedField::LevelType => {
7873 if level_type__.is_some() {
7874 return Err(serde::de::Error::duplicate_field("levelType"));
7875 }
7876 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
7877 }
7878 GeneratedField::TableInfos => {
7879 if table_infos__.is_some() {
7880 return Err(serde::de::Error::duplicate_field("tableInfos"));
7881 }
7882 table_infos__ = Some(map_.next_value()?);
7883 }
7884 GeneratedField::TotalFileSize => {
7885 if total_file_size__.is_some() {
7886 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7887 }
7888 total_file_size__ =
7889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7890 ;
7891 }
7892 GeneratedField::SubLevelId => {
7893 if sub_level_id__.is_some() {
7894 return Err(serde::de::Error::duplicate_field("subLevelId"));
7895 }
7896 sub_level_id__ =
7897 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7898 ;
7899 }
7900 GeneratedField::UncompressedFileSize => {
7901 if uncompressed_file_size__.is_some() {
7902 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
7903 }
7904 uncompressed_file_size__ =
7905 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7906 ;
7907 }
7908 GeneratedField::VnodePartitionCount => {
7909 if vnode_partition_count__.is_some() {
7910 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7911 }
7912 vnode_partition_count__ =
7913 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7914 ;
7915 }
7916 }
7917 }
7918 Ok(Level {
7919 level_idx: level_idx__.unwrap_or_default(),
7920 level_type: level_type__.unwrap_or_default(),
7921 table_infos: table_infos__.unwrap_or_default(),
7922 total_file_size: total_file_size__.unwrap_or_default(),
7923 sub_level_id: sub_level_id__.unwrap_or_default(),
7924 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
7925 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7926 })
7927 }
7928 }
7929 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
7930 }
7931}
7932impl serde::Serialize for LevelHandler {
7933 #[allow(deprecated)]
7934 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7935 where
7936 S: serde::Serializer,
7937 {
7938 use serde::ser::SerializeStruct;
7939 let mut len = 0;
7940 if self.level != 0 {
7941 len += 1;
7942 }
7943 if !self.tasks.is_empty() {
7944 len += 1;
7945 }
7946 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
7947 if self.level != 0 {
7948 struct_ser.serialize_field("level", &self.level)?;
7949 }
7950 if !self.tasks.is_empty() {
7951 struct_ser.serialize_field("tasks", &self.tasks)?;
7952 }
7953 struct_ser.end()
7954 }
7955}
7956impl<'de> serde::Deserialize<'de> for LevelHandler {
7957 #[allow(deprecated)]
7958 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7959 where
7960 D: serde::Deserializer<'de>,
7961 {
7962 const FIELDS: &[&str] = &[
7963 "level",
7964 "tasks",
7965 ];
7966
7967 #[allow(clippy::enum_variant_names)]
7968 enum GeneratedField {
7969 Level,
7970 Tasks,
7971 }
7972 impl<'de> serde::Deserialize<'de> for GeneratedField {
7973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7974 where
7975 D: serde::Deserializer<'de>,
7976 {
7977 struct GeneratedVisitor;
7978
7979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7980 type Value = GeneratedField;
7981
7982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7983 write!(formatter, "expected one of: {:?}", &FIELDS)
7984 }
7985
7986 #[allow(unused_variables)]
7987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7988 where
7989 E: serde::de::Error,
7990 {
7991 match value {
7992 "level" => Ok(GeneratedField::Level),
7993 "tasks" => Ok(GeneratedField::Tasks),
7994 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7995 }
7996 }
7997 }
7998 deserializer.deserialize_identifier(GeneratedVisitor)
7999 }
8000 }
8001 struct GeneratedVisitor;
8002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8003 type Value = LevelHandler;
8004
8005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8006 formatter.write_str("struct hummock.LevelHandler")
8007 }
8008
8009 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
8010 where
8011 V: serde::de::MapAccess<'de>,
8012 {
8013 let mut level__ = None;
8014 let mut tasks__ = None;
8015 while let Some(k) = map_.next_key()? {
8016 match k {
8017 GeneratedField::Level => {
8018 if level__.is_some() {
8019 return Err(serde::de::Error::duplicate_field("level"));
8020 }
8021 level__ =
8022 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8023 ;
8024 }
8025 GeneratedField::Tasks => {
8026 if tasks__.is_some() {
8027 return Err(serde::de::Error::duplicate_field("tasks"));
8028 }
8029 tasks__ = Some(map_.next_value()?);
8030 }
8031 }
8032 }
8033 Ok(LevelHandler {
8034 level: level__.unwrap_or_default(),
8035 tasks: tasks__.unwrap_or_default(),
8036 })
8037 }
8038 }
8039 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
8040 }
8041}
8042impl serde::Serialize for level_handler::RunningCompactTask {
8043 #[allow(deprecated)]
8044 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8045 where
8046 S: serde::Serializer,
8047 {
8048 use serde::ser::SerializeStruct;
8049 let mut len = 0;
8050 if self.task_id != 0 {
8051 len += 1;
8052 }
8053 if !self.ssts.is_empty() {
8054 len += 1;
8055 }
8056 if self.total_file_size != 0 {
8057 len += 1;
8058 }
8059 if self.target_level != 0 {
8060 len += 1;
8061 }
8062 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
8063 if self.task_id != 0 {
8064 #[allow(clippy::needless_borrow)]
8065 #[allow(clippy::needless_borrows_for_generic_args)]
8066 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
8067 }
8068 if !self.ssts.is_empty() {
8069 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8070 }
8071 if self.total_file_size != 0 {
8072 #[allow(clippy::needless_borrow)]
8073 #[allow(clippy::needless_borrows_for_generic_args)]
8074 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8075 }
8076 if self.target_level != 0 {
8077 struct_ser.serialize_field("targetLevel", &self.target_level)?;
8078 }
8079 struct_ser.end()
8080 }
8081}
8082impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
8083 #[allow(deprecated)]
8084 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8085 where
8086 D: serde::Deserializer<'de>,
8087 {
8088 const FIELDS: &[&str] = &[
8089 "task_id",
8090 "taskId",
8091 "ssts",
8092 "total_file_size",
8093 "totalFileSize",
8094 "target_level",
8095 "targetLevel",
8096 ];
8097
8098 #[allow(clippy::enum_variant_names)]
8099 enum GeneratedField {
8100 TaskId,
8101 Ssts,
8102 TotalFileSize,
8103 TargetLevel,
8104 }
8105 impl<'de> serde::Deserialize<'de> for GeneratedField {
8106 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8107 where
8108 D: serde::Deserializer<'de>,
8109 {
8110 struct GeneratedVisitor;
8111
8112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8113 type Value = GeneratedField;
8114
8115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8116 write!(formatter, "expected one of: {:?}", &FIELDS)
8117 }
8118
8119 #[allow(unused_variables)]
8120 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8121 where
8122 E: serde::de::Error,
8123 {
8124 match value {
8125 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8126 "ssts" => Ok(GeneratedField::Ssts),
8127 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8128 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
8129 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8130 }
8131 }
8132 }
8133 deserializer.deserialize_identifier(GeneratedVisitor)
8134 }
8135 }
8136 struct GeneratedVisitor;
8137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8138 type Value = level_handler::RunningCompactTask;
8139
8140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8141 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
8142 }
8143
8144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
8145 where
8146 V: serde::de::MapAccess<'de>,
8147 {
8148 let mut task_id__ = None;
8149 let mut ssts__ = None;
8150 let mut total_file_size__ = None;
8151 let mut target_level__ = None;
8152 while let Some(k) = map_.next_key()? {
8153 match k {
8154 GeneratedField::TaskId => {
8155 if task_id__.is_some() {
8156 return Err(serde::de::Error::duplicate_field("taskId"));
8157 }
8158 task_id__ =
8159 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8160 ;
8161 }
8162 GeneratedField::Ssts => {
8163 if ssts__.is_some() {
8164 return Err(serde::de::Error::duplicate_field("ssts"));
8165 }
8166 ssts__ =
8167 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8168 .into_iter().map(|x| x.0).collect())
8169 ;
8170 }
8171 GeneratedField::TotalFileSize => {
8172 if total_file_size__.is_some() {
8173 return Err(serde::de::Error::duplicate_field("totalFileSize"));
8174 }
8175 total_file_size__ =
8176 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8177 ;
8178 }
8179 GeneratedField::TargetLevel => {
8180 if target_level__.is_some() {
8181 return Err(serde::de::Error::duplicate_field("targetLevel"));
8182 }
8183 target_level__ =
8184 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8185 ;
8186 }
8187 }
8188 }
8189 Ok(level_handler::RunningCompactTask {
8190 task_id: task_id__.unwrap_or_default(),
8191 ssts: ssts__.unwrap_or_default(),
8192 total_file_size: total_file_size__.unwrap_or_default(),
8193 target_level: target_level__.unwrap_or_default(),
8194 })
8195 }
8196 }
8197 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
8198 }
8199}
8200impl serde::Serialize for LevelType {
8201 #[allow(deprecated)]
8202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8203 where
8204 S: serde::Serializer,
8205 {
8206 let variant = match self {
8207 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
8208 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
8209 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
8210 };
8211 serializer.serialize_str(variant)
8212 }
8213}
8214impl<'de> serde::Deserialize<'de> for LevelType {
8215 #[allow(deprecated)]
8216 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8217 where
8218 D: serde::Deserializer<'de>,
8219 {
8220 const FIELDS: &[&str] = &[
8221 "LEVEL_TYPE_UNSPECIFIED",
8222 "LEVEL_TYPE_NONOVERLAPPING",
8223 "LEVEL_TYPE_OVERLAPPING",
8224 ];
8225
8226 struct GeneratedVisitor;
8227
8228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8229 type Value = LevelType;
8230
8231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8232 write!(formatter, "expected one of: {:?}", &FIELDS)
8233 }
8234
8235 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8236 where
8237 E: serde::de::Error,
8238 {
8239 i32::try_from(v)
8240 .ok()
8241 .and_then(|x| x.try_into().ok())
8242 .ok_or_else(|| {
8243 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8244 })
8245 }
8246
8247 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8248 where
8249 E: serde::de::Error,
8250 {
8251 i32::try_from(v)
8252 .ok()
8253 .and_then(|x| x.try_into().ok())
8254 .ok_or_else(|| {
8255 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8256 })
8257 }
8258
8259 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8260 where
8261 E: serde::de::Error,
8262 {
8263 match value {
8264 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
8265 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
8266 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
8267 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8268 }
8269 }
8270 }
8271 deserializer.deserialize_any(GeneratedVisitor)
8272 }
8273}
8274impl serde::Serialize for ListActiveWriteLimitRequest {
8275 #[allow(deprecated)]
8276 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8277 where
8278 S: serde::Serializer,
8279 {
8280 use serde::ser::SerializeStruct;
8281 let len = 0;
8282 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
8283 struct_ser.end()
8284 }
8285}
8286impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
8287 #[allow(deprecated)]
8288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8289 where
8290 D: serde::Deserializer<'de>,
8291 {
8292 const FIELDS: &[&str] = &[
8293 ];
8294
8295 #[allow(clippy::enum_variant_names)]
8296 enum GeneratedField {
8297 }
8298 impl<'de> serde::Deserialize<'de> for GeneratedField {
8299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8300 where
8301 D: serde::Deserializer<'de>,
8302 {
8303 struct GeneratedVisitor;
8304
8305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8306 type Value = GeneratedField;
8307
8308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8309 write!(formatter, "expected one of: {:?}", &FIELDS)
8310 }
8311
8312 #[allow(unused_variables)]
8313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8314 where
8315 E: serde::de::Error,
8316 {
8317 Err(serde::de::Error::unknown_field(value, FIELDS))
8318 }
8319 }
8320 deserializer.deserialize_identifier(GeneratedVisitor)
8321 }
8322 }
8323 struct GeneratedVisitor;
8324 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8325 type Value = ListActiveWriteLimitRequest;
8326
8327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8328 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
8329 }
8330
8331 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
8332 where
8333 V: serde::de::MapAccess<'de>,
8334 {
8335 while map_.next_key::<GeneratedField>()?.is_some() {
8336 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8337 }
8338 Ok(ListActiveWriteLimitRequest {
8339 })
8340 }
8341 }
8342 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
8343 }
8344}
8345impl serde::Serialize for ListActiveWriteLimitResponse {
8346 #[allow(deprecated)]
8347 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8348 where
8349 S: serde::Serializer,
8350 {
8351 use serde::ser::SerializeStruct;
8352 let mut len = 0;
8353 if !self.write_limits.is_empty() {
8354 len += 1;
8355 }
8356 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
8357 if !self.write_limits.is_empty() {
8358 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
8359 }
8360 struct_ser.end()
8361 }
8362}
8363impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
8364 #[allow(deprecated)]
8365 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8366 where
8367 D: serde::Deserializer<'de>,
8368 {
8369 const FIELDS: &[&str] = &[
8370 "write_limits",
8371 "writeLimits",
8372 ];
8373
8374 #[allow(clippy::enum_variant_names)]
8375 enum GeneratedField {
8376 WriteLimits,
8377 }
8378 impl<'de> serde::Deserialize<'de> for GeneratedField {
8379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8380 where
8381 D: serde::Deserializer<'de>,
8382 {
8383 struct GeneratedVisitor;
8384
8385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8386 type Value = GeneratedField;
8387
8388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8389 write!(formatter, "expected one of: {:?}", &FIELDS)
8390 }
8391
8392 #[allow(unused_variables)]
8393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8394 where
8395 E: serde::de::Error,
8396 {
8397 match value {
8398 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
8399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8400 }
8401 }
8402 }
8403 deserializer.deserialize_identifier(GeneratedVisitor)
8404 }
8405 }
8406 struct GeneratedVisitor;
8407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8408 type Value = ListActiveWriteLimitResponse;
8409
8410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8411 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
8412 }
8413
8414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
8415 where
8416 V: serde::de::MapAccess<'de>,
8417 {
8418 let mut write_limits__ = None;
8419 while let Some(k) = map_.next_key()? {
8420 match k {
8421 GeneratedField::WriteLimits => {
8422 if write_limits__.is_some() {
8423 return Err(serde::de::Error::duplicate_field("writeLimits"));
8424 }
8425 write_limits__ = Some(
8426 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
8427 .into_iter().map(|(k,v)| (k.0, v)).collect()
8428 );
8429 }
8430 }
8431 }
8432 Ok(ListActiveWriteLimitResponse {
8433 write_limits: write_limits__.unwrap_or_default(),
8434 })
8435 }
8436 }
8437 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
8438 }
8439}
8440impl serde::Serialize for ListBranchedObjectRequest {
8441 #[allow(deprecated)]
8442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8443 where
8444 S: serde::Serializer,
8445 {
8446 use serde::ser::SerializeStruct;
8447 let len = 0;
8448 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
8449 struct_ser.end()
8450 }
8451}
8452impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
8453 #[allow(deprecated)]
8454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8455 where
8456 D: serde::Deserializer<'de>,
8457 {
8458 const FIELDS: &[&str] = &[
8459 ];
8460
8461 #[allow(clippy::enum_variant_names)]
8462 enum GeneratedField {
8463 }
8464 impl<'de> serde::Deserialize<'de> for GeneratedField {
8465 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8466 where
8467 D: serde::Deserializer<'de>,
8468 {
8469 struct GeneratedVisitor;
8470
8471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8472 type Value = GeneratedField;
8473
8474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8475 write!(formatter, "expected one of: {:?}", &FIELDS)
8476 }
8477
8478 #[allow(unused_variables)]
8479 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8480 where
8481 E: serde::de::Error,
8482 {
8483 Err(serde::de::Error::unknown_field(value, FIELDS))
8484 }
8485 }
8486 deserializer.deserialize_identifier(GeneratedVisitor)
8487 }
8488 }
8489 struct GeneratedVisitor;
8490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8491 type Value = ListBranchedObjectRequest;
8492
8493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8494 formatter.write_str("struct hummock.ListBranchedObjectRequest")
8495 }
8496
8497 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
8498 where
8499 V: serde::de::MapAccess<'de>,
8500 {
8501 while map_.next_key::<GeneratedField>()?.is_some() {
8502 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8503 }
8504 Ok(ListBranchedObjectRequest {
8505 })
8506 }
8507 }
8508 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
8509 }
8510}
8511impl serde::Serialize for ListBranchedObjectResponse {
8512 #[allow(deprecated)]
8513 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8514 where
8515 S: serde::Serializer,
8516 {
8517 use serde::ser::SerializeStruct;
8518 let mut len = 0;
8519 if !self.branched_objects.is_empty() {
8520 len += 1;
8521 }
8522 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
8523 if !self.branched_objects.is_empty() {
8524 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
8525 }
8526 struct_ser.end()
8527 }
8528}
8529impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
8530 #[allow(deprecated)]
8531 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8532 where
8533 D: serde::Deserializer<'de>,
8534 {
8535 const FIELDS: &[&str] = &[
8536 "branched_objects",
8537 "branchedObjects",
8538 ];
8539
8540 #[allow(clippy::enum_variant_names)]
8541 enum GeneratedField {
8542 BranchedObjects,
8543 }
8544 impl<'de> serde::Deserialize<'de> for GeneratedField {
8545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8546 where
8547 D: serde::Deserializer<'de>,
8548 {
8549 struct GeneratedVisitor;
8550
8551 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8552 type Value = GeneratedField;
8553
8554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8555 write!(formatter, "expected one of: {:?}", &FIELDS)
8556 }
8557
8558 #[allow(unused_variables)]
8559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8560 where
8561 E: serde::de::Error,
8562 {
8563 match value {
8564 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
8565 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8566 }
8567 }
8568 }
8569 deserializer.deserialize_identifier(GeneratedVisitor)
8570 }
8571 }
8572 struct GeneratedVisitor;
8573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8574 type Value = ListBranchedObjectResponse;
8575
8576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8577 formatter.write_str("struct hummock.ListBranchedObjectResponse")
8578 }
8579
8580 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
8581 where
8582 V: serde::de::MapAccess<'de>,
8583 {
8584 let mut branched_objects__ = None;
8585 while let Some(k) = map_.next_key()? {
8586 match k {
8587 GeneratedField::BranchedObjects => {
8588 if branched_objects__.is_some() {
8589 return Err(serde::de::Error::duplicate_field("branchedObjects"));
8590 }
8591 branched_objects__ = Some(map_.next_value()?);
8592 }
8593 }
8594 }
8595 Ok(ListBranchedObjectResponse {
8596 branched_objects: branched_objects__.unwrap_or_default(),
8597 })
8598 }
8599 }
8600 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
8601 }
8602}
8603impl serde::Serialize for ListCompactTaskAssignmentRequest {
8604 #[allow(deprecated)]
8605 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8606 where
8607 S: serde::Serializer,
8608 {
8609 use serde::ser::SerializeStruct;
8610 let len = 0;
8611 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
8612 struct_ser.end()
8613 }
8614}
8615impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
8616 #[allow(deprecated)]
8617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8618 where
8619 D: serde::Deserializer<'de>,
8620 {
8621 const FIELDS: &[&str] = &[
8622 ];
8623
8624 #[allow(clippy::enum_variant_names)]
8625 enum GeneratedField {
8626 }
8627 impl<'de> serde::Deserialize<'de> for GeneratedField {
8628 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8629 where
8630 D: serde::Deserializer<'de>,
8631 {
8632 struct GeneratedVisitor;
8633
8634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8635 type Value = GeneratedField;
8636
8637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8638 write!(formatter, "expected one of: {:?}", &FIELDS)
8639 }
8640
8641 #[allow(unused_variables)]
8642 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8643 where
8644 E: serde::de::Error,
8645 {
8646 Err(serde::de::Error::unknown_field(value, FIELDS))
8647 }
8648 }
8649 deserializer.deserialize_identifier(GeneratedVisitor)
8650 }
8651 }
8652 struct GeneratedVisitor;
8653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8654 type Value = ListCompactTaskAssignmentRequest;
8655
8656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8657 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
8658 }
8659
8660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
8661 where
8662 V: serde::de::MapAccess<'de>,
8663 {
8664 while map_.next_key::<GeneratedField>()?.is_some() {
8665 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8666 }
8667 Ok(ListCompactTaskAssignmentRequest {
8668 })
8669 }
8670 }
8671 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
8672 }
8673}
8674impl serde::Serialize for ListCompactTaskAssignmentResponse {
8675 #[allow(deprecated)]
8676 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8677 where
8678 S: serde::Serializer,
8679 {
8680 use serde::ser::SerializeStruct;
8681 let mut len = 0;
8682 if !self.task_assignment.is_empty() {
8683 len += 1;
8684 }
8685 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
8686 if !self.task_assignment.is_empty() {
8687 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
8688 }
8689 struct_ser.end()
8690 }
8691}
8692impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
8693 #[allow(deprecated)]
8694 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8695 where
8696 D: serde::Deserializer<'de>,
8697 {
8698 const FIELDS: &[&str] = &[
8699 "task_assignment",
8700 "taskAssignment",
8701 ];
8702
8703 #[allow(clippy::enum_variant_names)]
8704 enum GeneratedField {
8705 TaskAssignment,
8706 }
8707 impl<'de> serde::Deserialize<'de> for GeneratedField {
8708 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8709 where
8710 D: serde::Deserializer<'de>,
8711 {
8712 struct GeneratedVisitor;
8713
8714 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8715 type Value = GeneratedField;
8716
8717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8718 write!(formatter, "expected one of: {:?}", &FIELDS)
8719 }
8720
8721 #[allow(unused_variables)]
8722 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8723 where
8724 E: serde::de::Error,
8725 {
8726 match value {
8727 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
8728 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8729 }
8730 }
8731 }
8732 deserializer.deserialize_identifier(GeneratedVisitor)
8733 }
8734 }
8735 struct GeneratedVisitor;
8736 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8737 type Value = ListCompactTaskAssignmentResponse;
8738
8739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8740 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
8741 }
8742
8743 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
8744 where
8745 V: serde::de::MapAccess<'de>,
8746 {
8747 let mut task_assignment__ = None;
8748 while let Some(k) = map_.next_key()? {
8749 match k {
8750 GeneratedField::TaskAssignment => {
8751 if task_assignment__.is_some() {
8752 return Err(serde::de::Error::duplicate_field("taskAssignment"));
8753 }
8754 task_assignment__ = Some(map_.next_value()?);
8755 }
8756 }
8757 }
8758 Ok(ListCompactTaskAssignmentResponse {
8759 task_assignment: task_assignment__.unwrap_or_default(),
8760 })
8761 }
8762 }
8763 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
8764 }
8765}
8766impl serde::Serialize for ListCompactTaskProgressRequest {
8767 #[allow(deprecated)]
8768 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8769 where
8770 S: serde::Serializer,
8771 {
8772 use serde::ser::SerializeStruct;
8773 let len = 0;
8774 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
8775 struct_ser.end()
8776 }
8777}
8778impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
8779 #[allow(deprecated)]
8780 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8781 where
8782 D: serde::Deserializer<'de>,
8783 {
8784 const FIELDS: &[&str] = &[
8785 ];
8786
8787 #[allow(clippy::enum_variant_names)]
8788 enum GeneratedField {
8789 }
8790 impl<'de> serde::Deserialize<'de> for GeneratedField {
8791 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8792 where
8793 D: serde::Deserializer<'de>,
8794 {
8795 struct GeneratedVisitor;
8796
8797 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8798 type Value = GeneratedField;
8799
8800 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8801 write!(formatter, "expected one of: {:?}", &FIELDS)
8802 }
8803
8804 #[allow(unused_variables)]
8805 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8806 where
8807 E: serde::de::Error,
8808 {
8809 Err(serde::de::Error::unknown_field(value, FIELDS))
8810 }
8811 }
8812 deserializer.deserialize_identifier(GeneratedVisitor)
8813 }
8814 }
8815 struct GeneratedVisitor;
8816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8817 type Value = ListCompactTaskProgressRequest;
8818
8819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8820 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
8821 }
8822
8823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
8824 where
8825 V: serde::de::MapAccess<'de>,
8826 {
8827 while map_.next_key::<GeneratedField>()?.is_some() {
8828 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8829 }
8830 Ok(ListCompactTaskProgressRequest {
8831 })
8832 }
8833 }
8834 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
8835 }
8836}
8837impl serde::Serialize for ListCompactTaskProgressResponse {
8838 #[allow(deprecated)]
8839 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8840 where
8841 S: serde::Serializer,
8842 {
8843 use serde::ser::SerializeStruct;
8844 let mut len = 0;
8845 if !self.task_progress.is_empty() {
8846 len += 1;
8847 }
8848 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
8849 if !self.task_progress.is_empty() {
8850 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
8851 }
8852 struct_ser.end()
8853 }
8854}
8855impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
8856 #[allow(deprecated)]
8857 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8858 where
8859 D: serde::Deserializer<'de>,
8860 {
8861 const FIELDS: &[&str] = &[
8862 "task_progress",
8863 "taskProgress",
8864 ];
8865
8866 #[allow(clippy::enum_variant_names)]
8867 enum GeneratedField {
8868 TaskProgress,
8869 }
8870 impl<'de> serde::Deserialize<'de> for GeneratedField {
8871 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8872 where
8873 D: serde::Deserializer<'de>,
8874 {
8875 struct GeneratedVisitor;
8876
8877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8878 type Value = GeneratedField;
8879
8880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8881 write!(formatter, "expected one of: {:?}", &FIELDS)
8882 }
8883
8884 #[allow(unused_variables)]
8885 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8886 where
8887 E: serde::de::Error,
8888 {
8889 match value {
8890 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
8891 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8892 }
8893 }
8894 }
8895 deserializer.deserialize_identifier(GeneratedVisitor)
8896 }
8897 }
8898 struct GeneratedVisitor;
8899 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8900 type Value = ListCompactTaskProgressResponse;
8901
8902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8903 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
8904 }
8905
8906 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
8907 where
8908 V: serde::de::MapAccess<'de>,
8909 {
8910 let mut task_progress__ = None;
8911 while let Some(k) = map_.next_key()? {
8912 match k {
8913 GeneratedField::TaskProgress => {
8914 if task_progress__.is_some() {
8915 return Err(serde::de::Error::duplicate_field("taskProgress"));
8916 }
8917 task_progress__ = Some(map_.next_value()?);
8918 }
8919 }
8920 }
8921 Ok(ListCompactTaskProgressResponse {
8922 task_progress: task_progress__.unwrap_or_default(),
8923 })
8924 }
8925 }
8926 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
8927 }
8928}
8929impl serde::Serialize for ListHummockMetaConfigRequest {
8930 #[allow(deprecated)]
8931 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8932 where
8933 S: serde::Serializer,
8934 {
8935 use serde::ser::SerializeStruct;
8936 let len = 0;
8937 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
8938 struct_ser.end()
8939 }
8940}
8941impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
8942 #[allow(deprecated)]
8943 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8944 where
8945 D: serde::Deserializer<'de>,
8946 {
8947 const FIELDS: &[&str] = &[
8948 ];
8949
8950 #[allow(clippy::enum_variant_names)]
8951 enum GeneratedField {
8952 }
8953 impl<'de> serde::Deserialize<'de> for GeneratedField {
8954 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8955 where
8956 D: serde::Deserializer<'de>,
8957 {
8958 struct GeneratedVisitor;
8959
8960 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8961 type Value = GeneratedField;
8962
8963 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8964 write!(formatter, "expected one of: {:?}", &FIELDS)
8965 }
8966
8967 #[allow(unused_variables)]
8968 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8969 where
8970 E: serde::de::Error,
8971 {
8972 Err(serde::de::Error::unknown_field(value, FIELDS))
8973 }
8974 }
8975 deserializer.deserialize_identifier(GeneratedVisitor)
8976 }
8977 }
8978 struct GeneratedVisitor;
8979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8980 type Value = ListHummockMetaConfigRequest;
8981
8982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8983 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
8984 }
8985
8986 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
8987 where
8988 V: serde::de::MapAccess<'de>,
8989 {
8990 while map_.next_key::<GeneratedField>()?.is_some() {
8991 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8992 }
8993 Ok(ListHummockMetaConfigRequest {
8994 })
8995 }
8996 }
8997 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
8998 }
8999}
9000impl serde::Serialize for ListHummockMetaConfigResponse {
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.configs.is_empty() {
9009 len += 1;
9010 }
9011 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
9012 if !self.configs.is_empty() {
9013 struct_ser.serialize_field("configs", &self.configs)?;
9014 }
9015 struct_ser.end()
9016 }
9017}
9018impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
9019 #[allow(deprecated)]
9020 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9021 where
9022 D: serde::Deserializer<'de>,
9023 {
9024 const FIELDS: &[&str] = &[
9025 "configs",
9026 ];
9027
9028 #[allow(clippy::enum_variant_names)]
9029 enum GeneratedField {
9030 Configs,
9031 }
9032 impl<'de> serde::Deserialize<'de> for GeneratedField {
9033 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9034 where
9035 D: serde::Deserializer<'de>,
9036 {
9037 struct GeneratedVisitor;
9038
9039 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9040 type Value = GeneratedField;
9041
9042 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9043 write!(formatter, "expected one of: {:?}", &FIELDS)
9044 }
9045
9046 #[allow(unused_variables)]
9047 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9048 where
9049 E: serde::de::Error,
9050 {
9051 match value {
9052 "configs" => Ok(GeneratedField::Configs),
9053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9054 }
9055 }
9056 }
9057 deserializer.deserialize_identifier(GeneratedVisitor)
9058 }
9059 }
9060 struct GeneratedVisitor;
9061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9062 type Value = ListHummockMetaConfigResponse;
9063
9064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9065 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
9066 }
9067
9068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
9069 where
9070 V: serde::de::MapAccess<'de>,
9071 {
9072 let mut configs__ = None;
9073 while let Some(k) = map_.next_key()? {
9074 match k {
9075 GeneratedField::Configs => {
9076 if configs__.is_some() {
9077 return Err(serde::de::Error::duplicate_field("configs"));
9078 }
9079 configs__ = Some(
9080 map_.next_value::<std::collections::HashMap<_, _>>()?
9081 );
9082 }
9083 }
9084 }
9085 Ok(ListHummockMetaConfigResponse {
9086 configs: configs__.unwrap_or_default(),
9087 })
9088 }
9089 }
9090 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
9091 }
9092}
9093impl serde::Serialize for ListVersionDeltasRequest {
9094 #[allow(deprecated)]
9095 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9096 where
9097 S: serde::Serializer,
9098 {
9099 use serde::ser::SerializeStruct;
9100 let mut len = 0;
9101 if self.start_id != 0 {
9102 len += 1;
9103 }
9104 if self.num_limit != 0 {
9105 len += 1;
9106 }
9107 if self.committed_epoch_limit != 0 {
9108 len += 1;
9109 }
9110 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
9111 if self.start_id != 0 {
9112 #[allow(clippy::needless_borrow)]
9113 #[allow(clippy::needless_borrows_for_generic_args)]
9114 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
9115 }
9116 if self.num_limit != 0 {
9117 struct_ser.serialize_field("numLimit", &self.num_limit)?;
9118 }
9119 if self.committed_epoch_limit != 0 {
9120 #[allow(clippy::needless_borrow)]
9121 #[allow(clippy::needless_borrows_for_generic_args)]
9122 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
9123 }
9124 struct_ser.end()
9125 }
9126}
9127impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
9128 #[allow(deprecated)]
9129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9130 where
9131 D: serde::Deserializer<'de>,
9132 {
9133 const FIELDS: &[&str] = &[
9134 "start_id",
9135 "startId",
9136 "num_limit",
9137 "numLimit",
9138 "committed_epoch_limit",
9139 "committedEpochLimit",
9140 ];
9141
9142 #[allow(clippy::enum_variant_names)]
9143 enum GeneratedField {
9144 StartId,
9145 NumLimit,
9146 CommittedEpochLimit,
9147 }
9148 impl<'de> serde::Deserialize<'de> for GeneratedField {
9149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9150 where
9151 D: serde::Deserializer<'de>,
9152 {
9153 struct GeneratedVisitor;
9154
9155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9156 type Value = GeneratedField;
9157
9158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9159 write!(formatter, "expected one of: {:?}", &FIELDS)
9160 }
9161
9162 #[allow(unused_variables)]
9163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9164 where
9165 E: serde::de::Error,
9166 {
9167 match value {
9168 "startId" | "start_id" => Ok(GeneratedField::StartId),
9169 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
9170 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
9171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9172 }
9173 }
9174 }
9175 deserializer.deserialize_identifier(GeneratedVisitor)
9176 }
9177 }
9178 struct GeneratedVisitor;
9179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9180 type Value = ListVersionDeltasRequest;
9181
9182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9183 formatter.write_str("struct hummock.ListVersionDeltasRequest")
9184 }
9185
9186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
9187 where
9188 V: serde::de::MapAccess<'de>,
9189 {
9190 let mut start_id__ = None;
9191 let mut num_limit__ = None;
9192 let mut committed_epoch_limit__ = None;
9193 while let Some(k) = map_.next_key()? {
9194 match k {
9195 GeneratedField::StartId => {
9196 if start_id__.is_some() {
9197 return Err(serde::de::Error::duplicate_field("startId"));
9198 }
9199 start_id__ =
9200 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9201 ;
9202 }
9203 GeneratedField::NumLimit => {
9204 if num_limit__.is_some() {
9205 return Err(serde::de::Error::duplicate_field("numLimit"));
9206 }
9207 num_limit__ =
9208 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9209 ;
9210 }
9211 GeneratedField::CommittedEpochLimit => {
9212 if committed_epoch_limit__.is_some() {
9213 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
9214 }
9215 committed_epoch_limit__ =
9216 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9217 ;
9218 }
9219 }
9220 }
9221 Ok(ListVersionDeltasRequest {
9222 start_id: start_id__.unwrap_or_default(),
9223 num_limit: num_limit__.unwrap_or_default(),
9224 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
9225 })
9226 }
9227 }
9228 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
9229 }
9230}
9231impl serde::Serialize for ListVersionDeltasResponse {
9232 #[allow(deprecated)]
9233 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9234 where
9235 S: serde::Serializer,
9236 {
9237 use serde::ser::SerializeStruct;
9238 let mut len = 0;
9239 if self.version_deltas.is_some() {
9240 len += 1;
9241 }
9242 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
9243 if let Some(v) = self.version_deltas.as_ref() {
9244 struct_ser.serialize_field("versionDeltas", v)?;
9245 }
9246 struct_ser.end()
9247 }
9248}
9249impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
9250 #[allow(deprecated)]
9251 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9252 where
9253 D: serde::Deserializer<'de>,
9254 {
9255 const FIELDS: &[&str] = &[
9256 "version_deltas",
9257 "versionDeltas",
9258 ];
9259
9260 #[allow(clippy::enum_variant_names)]
9261 enum GeneratedField {
9262 VersionDeltas,
9263 }
9264 impl<'de> serde::Deserialize<'de> for GeneratedField {
9265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9266 where
9267 D: serde::Deserializer<'de>,
9268 {
9269 struct GeneratedVisitor;
9270
9271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9272 type Value = GeneratedField;
9273
9274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9275 write!(formatter, "expected one of: {:?}", &FIELDS)
9276 }
9277
9278 #[allow(unused_variables)]
9279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9280 where
9281 E: serde::de::Error,
9282 {
9283 match value {
9284 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
9285 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9286 }
9287 }
9288 }
9289 deserializer.deserialize_identifier(GeneratedVisitor)
9290 }
9291 }
9292 struct GeneratedVisitor;
9293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9294 type Value = ListVersionDeltasResponse;
9295
9296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9297 formatter.write_str("struct hummock.ListVersionDeltasResponse")
9298 }
9299
9300 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
9301 where
9302 V: serde::de::MapAccess<'de>,
9303 {
9304 let mut version_deltas__ = None;
9305 while let Some(k) = map_.next_key()? {
9306 match k {
9307 GeneratedField::VersionDeltas => {
9308 if version_deltas__.is_some() {
9309 return Err(serde::de::Error::duplicate_field("versionDeltas"));
9310 }
9311 version_deltas__ = map_.next_value()?;
9312 }
9313 }
9314 }
9315 Ok(ListVersionDeltasResponse {
9316 version_deltas: version_deltas__,
9317 })
9318 }
9319 }
9320 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
9321 }
9322}
9323impl serde::Serialize for MergeCompactionGroupRequest {
9324 #[allow(deprecated)]
9325 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9326 where
9327 S: serde::Serializer,
9328 {
9329 use serde::ser::SerializeStruct;
9330 let mut len = 0;
9331 if self.left_group_id != 0 {
9332 len += 1;
9333 }
9334 if self.right_group_id != 0 {
9335 len += 1;
9336 }
9337 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
9338 if self.left_group_id != 0 {
9339 #[allow(clippy::needless_borrow)]
9340 #[allow(clippy::needless_borrows_for_generic_args)]
9341 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
9342 }
9343 if self.right_group_id != 0 {
9344 #[allow(clippy::needless_borrow)]
9345 #[allow(clippy::needless_borrows_for_generic_args)]
9346 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
9347 }
9348 struct_ser.end()
9349 }
9350}
9351impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
9352 #[allow(deprecated)]
9353 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9354 where
9355 D: serde::Deserializer<'de>,
9356 {
9357 const FIELDS: &[&str] = &[
9358 "left_group_id",
9359 "leftGroupId",
9360 "right_group_id",
9361 "rightGroupId",
9362 ];
9363
9364 #[allow(clippy::enum_variant_names)]
9365 enum GeneratedField {
9366 LeftGroupId,
9367 RightGroupId,
9368 }
9369 impl<'de> serde::Deserialize<'de> for GeneratedField {
9370 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9371 where
9372 D: serde::Deserializer<'de>,
9373 {
9374 struct GeneratedVisitor;
9375
9376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9377 type Value = GeneratedField;
9378
9379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9380 write!(formatter, "expected one of: {:?}", &FIELDS)
9381 }
9382
9383 #[allow(unused_variables)]
9384 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9385 where
9386 E: serde::de::Error,
9387 {
9388 match value {
9389 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
9390 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
9391 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9392 }
9393 }
9394 }
9395 deserializer.deserialize_identifier(GeneratedVisitor)
9396 }
9397 }
9398 struct GeneratedVisitor;
9399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9400 type Value = MergeCompactionGroupRequest;
9401
9402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9403 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
9404 }
9405
9406 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
9407 where
9408 V: serde::de::MapAccess<'de>,
9409 {
9410 let mut left_group_id__ = None;
9411 let mut right_group_id__ = None;
9412 while let Some(k) = map_.next_key()? {
9413 match k {
9414 GeneratedField::LeftGroupId => {
9415 if left_group_id__.is_some() {
9416 return Err(serde::de::Error::duplicate_field("leftGroupId"));
9417 }
9418 left_group_id__ =
9419 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9420 ;
9421 }
9422 GeneratedField::RightGroupId => {
9423 if right_group_id__.is_some() {
9424 return Err(serde::de::Error::duplicate_field("rightGroupId"));
9425 }
9426 right_group_id__ =
9427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9428 ;
9429 }
9430 }
9431 }
9432 Ok(MergeCompactionGroupRequest {
9433 left_group_id: left_group_id__.unwrap_or_default(),
9434 right_group_id: right_group_id__.unwrap_or_default(),
9435 })
9436 }
9437 }
9438 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
9439 }
9440}
9441impl serde::Serialize for MergeCompactionGroupResponse {
9442 #[allow(deprecated)]
9443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9444 where
9445 S: serde::Serializer,
9446 {
9447 use serde::ser::SerializeStruct;
9448 let len = 0;
9449 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
9450 struct_ser.end()
9451 }
9452}
9453impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
9454 #[allow(deprecated)]
9455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9456 where
9457 D: serde::Deserializer<'de>,
9458 {
9459 const FIELDS: &[&str] = &[
9460 ];
9461
9462 #[allow(clippy::enum_variant_names)]
9463 enum GeneratedField {
9464 }
9465 impl<'de> serde::Deserialize<'de> for GeneratedField {
9466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9467 where
9468 D: serde::Deserializer<'de>,
9469 {
9470 struct GeneratedVisitor;
9471
9472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9473 type Value = GeneratedField;
9474
9475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9476 write!(formatter, "expected one of: {:?}", &FIELDS)
9477 }
9478
9479 #[allow(unused_variables)]
9480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9481 where
9482 E: serde::de::Error,
9483 {
9484 Err(serde::de::Error::unknown_field(value, FIELDS))
9485 }
9486 }
9487 deserializer.deserialize_identifier(GeneratedVisitor)
9488 }
9489 }
9490 struct GeneratedVisitor;
9491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9492 type Value = MergeCompactionGroupResponse;
9493
9494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9495 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
9496 }
9497
9498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
9499 where
9500 V: serde::de::MapAccess<'de>,
9501 {
9502 while map_.next_key::<GeneratedField>()?.is_some() {
9503 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9504 }
9505 Ok(MergeCompactionGroupResponse {
9506 })
9507 }
9508 }
9509 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
9510 }
9511}
9512impl serde::Serialize for NewL0SubLevel {
9513 #[allow(deprecated)]
9514 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9515 where
9516 S: serde::Serializer,
9517 {
9518 use serde::ser::SerializeStruct;
9519 let mut len = 0;
9520 if !self.inserted_table_infos.is_empty() {
9521 len += 1;
9522 }
9523 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
9524 if !self.inserted_table_infos.is_empty() {
9525 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
9526 }
9527 struct_ser.end()
9528 }
9529}
9530impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
9531 #[allow(deprecated)]
9532 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9533 where
9534 D: serde::Deserializer<'de>,
9535 {
9536 const FIELDS: &[&str] = &[
9537 "inserted_table_infos",
9538 "insertedTableInfos",
9539 ];
9540
9541 #[allow(clippy::enum_variant_names)]
9542 enum GeneratedField {
9543 InsertedTableInfos,
9544 }
9545 impl<'de> serde::Deserialize<'de> for GeneratedField {
9546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9547 where
9548 D: serde::Deserializer<'de>,
9549 {
9550 struct GeneratedVisitor;
9551
9552 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9553 type Value = GeneratedField;
9554
9555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9556 write!(formatter, "expected one of: {:?}", &FIELDS)
9557 }
9558
9559 #[allow(unused_variables)]
9560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9561 where
9562 E: serde::de::Error,
9563 {
9564 match value {
9565 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
9566 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9567 }
9568 }
9569 }
9570 deserializer.deserialize_identifier(GeneratedVisitor)
9571 }
9572 }
9573 struct GeneratedVisitor;
9574 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9575 type Value = NewL0SubLevel;
9576
9577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9578 formatter.write_str("struct hummock.NewL0SubLevel")
9579 }
9580
9581 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
9582 where
9583 V: serde::de::MapAccess<'de>,
9584 {
9585 let mut inserted_table_infos__ = None;
9586 while let Some(k) = map_.next_key()? {
9587 match k {
9588 GeneratedField::InsertedTableInfos => {
9589 if inserted_table_infos__.is_some() {
9590 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
9591 }
9592 inserted_table_infos__ = Some(map_.next_value()?);
9593 }
9594 }
9595 }
9596 Ok(NewL0SubLevel {
9597 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
9598 })
9599 }
9600 }
9601 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
9602 }
9603}
9604impl serde::Serialize for OverlappingLevel {
9605 #[allow(deprecated)]
9606 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9607 where
9608 S: serde::Serializer,
9609 {
9610 use serde::ser::SerializeStruct;
9611 let mut len = 0;
9612 if !self.sub_levels.is_empty() {
9613 len += 1;
9614 }
9615 if self.total_file_size != 0 {
9616 len += 1;
9617 }
9618 if self.uncompressed_file_size != 0 {
9619 len += 1;
9620 }
9621 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
9622 if !self.sub_levels.is_empty() {
9623 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
9624 }
9625 if self.total_file_size != 0 {
9626 #[allow(clippy::needless_borrow)]
9627 #[allow(clippy::needless_borrows_for_generic_args)]
9628 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9629 }
9630 if self.uncompressed_file_size != 0 {
9631 #[allow(clippy::needless_borrow)]
9632 #[allow(clippy::needless_borrows_for_generic_args)]
9633 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
9634 }
9635 struct_ser.end()
9636 }
9637}
9638impl<'de> serde::Deserialize<'de> for OverlappingLevel {
9639 #[allow(deprecated)]
9640 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9641 where
9642 D: serde::Deserializer<'de>,
9643 {
9644 const FIELDS: &[&str] = &[
9645 "sub_levels",
9646 "subLevels",
9647 "total_file_size",
9648 "totalFileSize",
9649 "uncompressed_file_size",
9650 "uncompressedFileSize",
9651 ];
9652
9653 #[allow(clippy::enum_variant_names)]
9654 enum GeneratedField {
9655 SubLevels,
9656 TotalFileSize,
9657 UncompressedFileSize,
9658 }
9659 impl<'de> serde::Deserialize<'de> for GeneratedField {
9660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9661 where
9662 D: serde::Deserializer<'de>,
9663 {
9664 struct GeneratedVisitor;
9665
9666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9667 type Value = GeneratedField;
9668
9669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9670 write!(formatter, "expected one of: {:?}", &FIELDS)
9671 }
9672
9673 #[allow(unused_variables)]
9674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9675 where
9676 E: serde::de::Error,
9677 {
9678 match value {
9679 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
9680 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9681 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
9682 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9683 }
9684 }
9685 }
9686 deserializer.deserialize_identifier(GeneratedVisitor)
9687 }
9688 }
9689 struct GeneratedVisitor;
9690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9691 type Value = OverlappingLevel;
9692
9693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9694 formatter.write_str("struct hummock.OverlappingLevel")
9695 }
9696
9697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
9698 where
9699 V: serde::de::MapAccess<'de>,
9700 {
9701 let mut sub_levels__ = None;
9702 let mut total_file_size__ = None;
9703 let mut uncompressed_file_size__ = None;
9704 while let Some(k) = map_.next_key()? {
9705 match k {
9706 GeneratedField::SubLevels => {
9707 if sub_levels__.is_some() {
9708 return Err(serde::de::Error::duplicate_field("subLevels"));
9709 }
9710 sub_levels__ = Some(map_.next_value()?);
9711 }
9712 GeneratedField::TotalFileSize => {
9713 if total_file_size__.is_some() {
9714 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9715 }
9716 total_file_size__ =
9717 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9718 ;
9719 }
9720 GeneratedField::UncompressedFileSize => {
9721 if uncompressed_file_size__.is_some() {
9722 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
9723 }
9724 uncompressed_file_size__ =
9725 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9726 ;
9727 }
9728 }
9729 }
9730 Ok(OverlappingLevel {
9731 sub_levels: sub_levels__.unwrap_or_default(),
9732 total_file_size: total_file_size__.unwrap_or_default(),
9733 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
9734 })
9735 }
9736 }
9737 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
9738 }
9739}
9740impl serde::Serialize for PinVersionRequest {
9741 #[allow(deprecated)]
9742 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9743 where
9744 S: serde::Serializer,
9745 {
9746 use serde::ser::SerializeStruct;
9747 let mut len = 0;
9748 if self.context_id != 0 {
9749 len += 1;
9750 }
9751 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
9752 if self.context_id != 0 {
9753 struct_ser.serialize_field("contextId", &self.context_id)?;
9754 }
9755 struct_ser.end()
9756 }
9757}
9758impl<'de> serde::Deserialize<'de> for PinVersionRequest {
9759 #[allow(deprecated)]
9760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9761 where
9762 D: serde::Deserializer<'de>,
9763 {
9764 const FIELDS: &[&str] = &[
9765 "context_id",
9766 "contextId",
9767 ];
9768
9769 #[allow(clippy::enum_variant_names)]
9770 enum GeneratedField {
9771 ContextId,
9772 }
9773 impl<'de> serde::Deserialize<'de> for GeneratedField {
9774 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9775 where
9776 D: serde::Deserializer<'de>,
9777 {
9778 struct GeneratedVisitor;
9779
9780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9781 type Value = GeneratedField;
9782
9783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9784 write!(formatter, "expected one of: {:?}", &FIELDS)
9785 }
9786
9787 #[allow(unused_variables)]
9788 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9789 where
9790 E: serde::de::Error,
9791 {
9792 match value {
9793 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
9794 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9795 }
9796 }
9797 }
9798 deserializer.deserialize_identifier(GeneratedVisitor)
9799 }
9800 }
9801 struct GeneratedVisitor;
9802 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9803 type Value = PinVersionRequest;
9804
9805 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9806 formatter.write_str("struct hummock.PinVersionRequest")
9807 }
9808
9809 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
9810 where
9811 V: serde::de::MapAccess<'de>,
9812 {
9813 let mut context_id__ = None;
9814 while let Some(k) = map_.next_key()? {
9815 match k {
9816 GeneratedField::ContextId => {
9817 if context_id__.is_some() {
9818 return Err(serde::de::Error::duplicate_field("contextId"));
9819 }
9820 context_id__ =
9821 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9822 ;
9823 }
9824 }
9825 }
9826 Ok(PinVersionRequest {
9827 context_id: context_id__.unwrap_or_default(),
9828 })
9829 }
9830 }
9831 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
9832 }
9833}
9834impl serde::Serialize for PinVersionResponse {
9835 #[allow(deprecated)]
9836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9837 where
9838 S: serde::Serializer,
9839 {
9840 use serde::ser::SerializeStruct;
9841 let mut len = 0;
9842 if self.pinned_version.is_some() {
9843 len += 1;
9844 }
9845 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
9846 if let Some(v) = self.pinned_version.as_ref() {
9847 struct_ser.serialize_field("pinnedVersion", v)?;
9848 }
9849 struct_ser.end()
9850 }
9851}
9852impl<'de> serde::Deserialize<'de> for PinVersionResponse {
9853 #[allow(deprecated)]
9854 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9855 where
9856 D: serde::Deserializer<'de>,
9857 {
9858 const FIELDS: &[&str] = &[
9859 "pinned_version",
9860 "pinnedVersion",
9861 ];
9862
9863 #[allow(clippy::enum_variant_names)]
9864 enum GeneratedField {
9865 PinnedVersion,
9866 }
9867 impl<'de> serde::Deserialize<'de> for GeneratedField {
9868 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9869 where
9870 D: serde::Deserializer<'de>,
9871 {
9872 struct GeneratedVisitor;
9873
9874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9875 type Value = GeneratedField;
9876
9877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9878 write!(formatter, "expected one of: {:?}", &FIELDS)
9879 }
9880
9881 #[allow(unused_variables)]
9882 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9883 where
9884 E: serde::de::Error,
9885 {
9886 match value {
9887 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
9888 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9889 }
9890 }
9891 }
9892 deserializer.deserialize_identifier(GeneratedVisitor)
9893 }
9894 }
9895 struct GeneratedVisitor;
9896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9897 type Value = PinVersionResponse;
9898
9899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9900 formatter.write_str("struct hummock.PinVersionResponse")
9901 }
9902
9903 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
9904 where
9905 V: serde::de::MapAccess<'de>,
9906 {
9907 let mut pinned_version__ = None;
9908 while let Some(k) = map_.next_key()? {
9909 match k {
9910 GeneratedField::PinnedVersion => {
9911 if pinned_version__.is_some() {
9912 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
9913 }
9914 pinned_version__ = map_.next_value()?;
9915 }
9916 }
9917 }
9918 Ok(PinVersionResponse {
9919 pinned_version: pinned_version__,
9920 })
9921 }
9922 }
9923 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
9924 }
9925}
9926impl serde::Serialize for PinnedVersionsSummary {
9927 #[allow(deprecated)]
9928 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9929 where
9930 S: serde::Serializer,
9931 {
9932 use serde::ser::SerializeStruct;
9933 let mut len = 0;
9934 if !self.pinned_versions.is_empty() {
9935 len += 1;
9936 }
9937 if !self.workers.is_empty() {
9938 len += 1;
9939 }
9940 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
9941 if !self.pinned_versions.is_empty() {
9942 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
9943 }
9944 if !self.workers.is_empty() {
9945 struct_ser.serialize_field("workers", &self.workers)?;
9946 }
9947 struct_ser.end()
9948 }
9949}
9950impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
9951 #[allow(deprecated)]
9952 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9953 where
9954 D: serde::Deserializer<'de>,
9955 {
9956 const FIELDS: &[&str] = &[
9957 "pinned_versions",
9958 "pinnedVersions",
9959 "workers",
9960 ];
9961
9962 #[allow(clippy::enum_variant_names)]
9963 enum GeneratedField {
9964 PinnedVersions,
9965 Workers,
9966 }
9967 impl<'de> serde::Deserialize<'de> for GeneratedField {
9968 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9969 where
9970 D: serde::Deserializer<'de>,
9971 {
9972 struct GeneratedVisitor;
9973
9974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9975 type Value = GeneratedField;
9976
9977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9978 write!(formatter, "expected one of: {:?}", &FIELDS)
9979 }
9980
9981 #[allow(unused_variables)]
9982 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9983 where
9984 E: serde::de::Error,
9985 {
9986 match value {
9987 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
9988 "workers" => Ok(GeneratedField::Workers),
9989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9990 }
9991 }
9992 }
9993 deserializer.deserialize_identifier(GeneratedVisitor)
9994 }
9995 }
9996 struct GeneratedVisitor;
9997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9998 type Value = PinnedVersionsSummary;
9999
10000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10001 formatter.write_str("struct hummock.PinnedVersionsSummary")
10002 }
10003
10004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
10005 where
10006 V: serde::de::MapAccess<'de>,
10007 {
10008 let mut pinned_versions__ = None;
10009 let mut workers__ = None;
10010 while let Some(k) = map_.next_key()? {
10011 match k {
10012 GeneratedField::PinnedVersions => {
10013 if pinned_versions__.is_some() {
10014 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
10015 }
10016 pinned_versions__ = Some(map_.next_value()?);
10017 }
10018 GeneratedField::Workers => {
10019 if workers__.is_some() {
10020 return Err(serde::de::Error::duplicate_field("workers"));
10021 }
10022 workers__ = Some(
10023 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10024 .into_iter().map(|(k,v)| (k.0, v)).collect()
10025 );
10026 }
10027 }
10028 }
10029 Ok(PinnedVersionsSummary {
10030 pinned_versions: pinned_versions__.unwrap_or_default(),
10031 workers: workers__.unwrap_or_default(),
10032 })
10033 }
10034 }
10035 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
10036 }
10037}
10038impl serde::Serialize for ReplayVersionDeltaRequest {
10039 #[allow(deprecated)]
10040 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10041 where
10042 S: serde::Serializer,
10043 {
10044 use serde::ser::SerializeStruct;
10045 let mut len = 0;
10046 if self.version_delta.is_some() {
10047 len += 1;
10048 }
10049 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
10050 if let Some(v) = self.version_delta.as_ref() {
10051 struct_ser.serialize_field("versionDelta", v)?;
10052 }
10053 struct_ser.end()
10054 }
10055}
10056impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
10057 #[allow(deprecated)]
10058 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10059 where
10060 D: serde::Deserializer<'de>,
10061 {
10062 const FIELDS: &[&str] = &[
10063 "version_delta",
10064 "versionDelta",
10065 ];
10066
10067 #[allow(clippy::enum_variant_names)]
10068 enum GeneratedField {
10069 VersionDelta,
10070 }
10071 impl<'de> serde::Deserialize<'de> for GeneratedField {
10072 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10073 where
10074 D: serde::Deserializer<'de>,
10075 {
10076 struct GeneratedVisitor;
10077
10078 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10079 type Value = GeneratedField;
10080
10081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10082 write!(formatter, "expected one of: {:?}", &FIELDS)
10083 }
10084
10085 #[allow(unused_variables)]
10086 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10087 where
10088 E: serde::de::Error,
10089 {
10090 match value {
10091 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
10092 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10093 }
10094 }
10095 }
10096 deserializer.deserialize_identifier(GeneratedVisitor)
10097 }
10098 }
10099 struct GeneratedVisitor;
10100 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10101 type Value = ReplayVersionDeltaRequest;
10102
10103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10104 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
10105 }
10106
10107 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
10108 where
10109 V: serde::de::MapAccess<'de>,
10110 {
10111 let mut version_delta__ = None;
10112 while let Some(k) = map_.next_key()? {
10113 match k {
10114 GeneratedField::VersionDelta => {
10115 if version_delta__.is_some() {
10116 return Err(serde::de::Error::duplicate_field("versionDelta"));
10117 }
10118 version_delta__ = map_.next_value()?;
10119 }
10120 }
10121 }
10122 Ok(ReplayVersionDeltaRequest {
10123 version_delta: version_delta__,
10124 })
10125 }
10126 }
10127 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
10128 }
10129}
10130impl serde::Serialize for ReplayVersionDeltaResponse {
10131 #[allow(deprecated)]
10132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10133 where
10134 S: serde::Serializer,
10135 {
10136 use serde::ser::SerializeStruct;
10137 let mut len = 0;
10138 if self.version.is_some() {
10139 len += 1;
10140 }
10141 if !self.modified_compaction_groups.is_empty() {
10142 len += 1;
10143 }
10144 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
10145 if let Some(v) = self.version.as_ref() {
10146 struct_ser.serialize_field("version", v)?;
10147 }
10148 if !self.modified_compaction_groups.is_empty() {
10149 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
10150 }
10151 struct_ser.end()
10152 }
10153}
10154impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
10155 #[allow(deprecated)]
10156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10157 where
10158 D: serde::Deserializer<'de>,
10159 {
10160 const FIELDS: &[&str] = &[
10161 "version",
10162 "modified_compaction_groups",
10163 "modifiedCompactionGroups",
10164 ];
10165
10166 #[allow(clippy::enum_variant_names)]
10167 enum GeneratedField {
10168 Version,
10169 ModifiedCompactionGroups,
10170 }
10171 impl<'de> serde::Deserialize<'de> for GeneratedField {
10172 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10173 where
10174 D: serde::Deserializer<'de>,
10175 {
10176 struct GeneratedVisitor;
10177
10178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10179 type Value = GeneratedField;
10180
10181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10182 write!(formatter, "expected one of: {:?}", &FIELDS)
10183 }
10184
10185 #[allow(unused_variables)]
10186 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10187 where
10188 E: serde::de::Error,
10189 {
10190 match value {
10191 "version" => Ok(GeneratedField::Version),
10192 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
10193 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10194 }
10195 }
10196 }
10197 deserializer.deserialize_identifier(GeneratedVisitor)
10198 }
10199 }
10200 struct GeneratedVisitor;
10201 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10202 type Value = ReplayVersionDeltaResponse;
10203
10204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10205 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
10206 }
10207
10208 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
10209 where
10210 V: serde::de::MapAccess<'de>,
10211 {
10212 let mut version__ = None;
10213 let mut modified_compaction_groups__ = None;
10214 while let Some(k) = map_.next_key()? {
10215 match k {
10216 GeneratedField::Version => {
10217 if version__.is_some() {
10218 return Err(serde::de::Error::duplicate_field("version"));
10219 }
10220 version__ = map_.next_value()?;
10221 }
10222 GeneratedField::ModifiedCompactionGroups => {
10223 if modified_compaction_groups__.is_some() {
10224 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
10225 }
10226 modified_compaction_groups__ =
10227 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10228 .into_iter().map(|x| x.0).collect())
10229 ;
10230 }
10231 }
10232 }
10233 Ok(ReplayVersionDeltaResponse {
10234 version: version__,
10235 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
10236 })
10237 }
10238 }
10239 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
10240 }
10241}
10242impl serde::Serialize for ReportCompactionTaskRequest {
10243 #[allow(deprecated)]
10244 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10245 where
10246 S: serde::Serializer,
10247 {
10248 use serde::ser::SerializeStruct;
10249 let mut len = 0;
10250 if self.event.is_some() {
10251 len += 1;
10252 }
10253 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
10254 if let Some(v) = self.event.as_ref() {
10255 match v {
10256 report_compaction_task_request::Event::ReportTask(v) => {
10257 struct_ser.serialize_field("reportTask", v)?;
10258 }
10259 report_compaction_task_request::Event::HeartBeat(v) => {
10260 struct_ser.serialize_field("heartBeat", v)?;
10261 }
10262 }
10263 }
10264 struct_ser.end()
10265 }
10266}
10267impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
10268 #[allow(deprecated)]
10269 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10270 where
10271 D: serde::Deserializer<'de>,
10272 {
10273 const FIELDS: &[&str] = &[
10274 "report_task",
10275 "reportTask",
10276 "heart_beat",
10277 "heartBeat",
10278 ];
10279
10280 #[allow(clippy::enum_variant_names)]
10281 enum GeneratedField {
10282 ReportTask,
10283 HeartBeat,
10284 }
10285 impl<'de> serde::Deserialize<'de> for GeneratedField {
10286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10287 where
10288 D: serde::Deserializer<'de>,
10289 {
10290 struct GeneratedVisitor;
10291
10292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10293 type Value = GeneratedField;
10294
10295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10296 write!(formatter, "expected one of: {:?}", &FIELDS)
10297 }
10298
10299 #[allow(unused_variables)]
10300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10301 where
10302 E: serde::de::Error,
10303 {
10304 match value {
10305 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
10306 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
10307 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10308 }
10309 }
10310 }
10311 deserializer.deserialize_identifier(GeneratedVisitor)
10312 }
10313 }
10314 struct GeneratedVisitor;
10315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10316 type Value = ReportCompactionTaskRequest;
10317
10318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10319 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
10320 }
10321
10322 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
10323 where
10324 V: serde::de::MapAccess<'de>,
10325 {
10326 let mut event__ = None;
10327 while let Some(k) = map_.next_key()? {
10328 match k {
10329 GeneratedField::ReportTask => {
10330 if event__.is_some() {
10331 return Err(serde::de::Error::duplicate_field("reportTask"));
10332 }
10333 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
10334;
10335 }
10336 GeneratedField::HeartBeat => {
10337 if event__.is_some() {
10338 return Err(serde::de::Error::duplicate_field("heartBeat"));
10339 }
10340 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
10341;
10342 }
10343 }
10344 }
10345 Ok(ReportCompactionTaskRequest {
10346 event: event__,
10347 })
10348 }
10349 }
10350 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
10351 }
10352}
10353impl serde::Serialize for report_compaction_task_request::HeartBeat {
10354 #[allow(deprecated)]
10355 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10356 where
10357 S: serde::Serializer,
10358 {
10359 use serde::ser::SerializeStruct;
10360 let mut len = 0;
10361 if !self.progress.is_empty() {
10362 len += 1;
10363 }
10364 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
10365 if !self.progress.is_empty() {
10366 struct_ser.serialize_field("progress", &self.progress)?;
10367 }
10368 struct_ser.end()
10369 }
10370}
10371impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
10372 #[allow(deprecated)]
10373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10374 where
10375 D: serde::Deserializer<'de>,
10376 {
10377 const FIELDS: &[&str] = &[
10378 "progress",
10379 ];
10380
10381 #[allow(clippy::enum_variant_names)]
10382 enum GeneratedField {
10383 Progress,
10384 }
10385 impl<'de> serde::Deserialize<'de> for GeneratedField {
10386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10387 where
10388 D: serde::Deserializer<'de>,
10389 {
10390 struct GeneratedVisitor;
10391
10392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10393 type Value = GeneratedField;
10394
10395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10396 write!(formatter, "expected one of: {:?}", &FIELDS)
10397 }
10398
10399 #[allow(unused_variables)]
10400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10401 where
10402 E: serde::de::Error,
10403 {
10404 match value {
10405 "progress" => Ok(GeneratedField::Progress),
10406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10407 }
10408 }
10409 }
10410 deserializer.deserialize_identifier(GeneratedVisitor)
10411 }
10412 }
10413 struct GeneratedVisitor;
10414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10415 type Value = report_compaction_task_request::HeartBeat;
10416
10417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10418 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
10419 }
10420
10421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
10422 where
10423 V: serde::de::MapAccess<'de>,
10424 {
10425 let mut progress__ = None;
10426 while let Some(k) = map_.next_key()? {
10427 match k {
10428 GeneratedField::Progress => {
10429 if progress__.is_some() {
10430 return Err(serde::de::Error::duplicate_field("progress"));
10431 }
10432 progress__ = Some(map_.next_value()?);
10433 }
10434 }
10435 }
10436 Ok(report_compaction_task_request::HeartBeat {
10437 progress: progress__.unwrap_or_default(),
10438 })
10439 }
10440 }
10441 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
10442 }
10443}
10444impl serde::Serialize for report_compaction_task_request::ReportTask {
10445 #[allow(deprecated)]
10446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10447 where
10448 S: serde::Serializer,
10449 {
10450 use serde::ser::SerializeStruct;
10451 let mut len = 0;
10452 if self.compact_task.is_some() {
10453 len += 1;
10454 }
10455 if !self.table_stats_change.is_empty() {
10456 len += 1;
10457 }
10458 if !self.object_timestamps.is_empty() {
10459 len += 1;
10460 }
10461 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
10462 if let Some(v) = self.compact_task.as_ref() {
10463 struct_ser.serialize_field("compactTask", v)?;
10464 }
10465 if !self.table_stats_change.is_empty() {
10466 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
10467 }
10468 if !self.object_timestamps.is_empty() {
10469 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
10470 .map(|(k, v)| (k, v.to_string())).collect();
10471 struct_ser.serialize_field("objectTimestamps", &v)?;
10472 }
10473 struct_ser.end()
10474 }
10475}
10476impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
10477 #[allow(deprecated)]
10478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10479 where
10480 D: serde::Deserializer<'de>,
10481 {
10482 const FIELDS: &[&str] = &[
10483 "compact_task",
10484 "compactTask",
10485 "table_stats_change",
10486 "tableStatsChange",
10487 "object_timestamps",
10488 "objectTimestamps",
10489 ];
10490
10491 #[allow(clippy::enum_variant_names)]
10492 enum GeneratedField {
10493 CompactTask,
10494 TableStatsChange,
10495 ObjectTimestamps,
10496 }
10497 impl<'de> serde::Deserialize<'de> for GeneratedField {
10498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10499 where
10500 D: serde::Deserializer<'de>,
10501 {
10502 struct GeneratedVisitor;
10503
10504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10505 type Value = GeneratedField;
10506
10507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10508 write!(formatter, "expected one of: {:?}", &FIELDS)
10509 }
10510
10511 #[allow(unused_variables)]
10512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10513 where
10514 E: serde::de::Error,
10515 {
10516 match value {
10517 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
10518 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
10519 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
10520 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10521 }
10522 }
10523 }
10524 deserializer.deserialize_identifier(GeneratedVisitor)
10525 }
10526 }
10527 struct GeneratedVisitor;
10528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10529 type Value = report_compaction_task_request::ReportTask;
10530
10531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10532 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
10533 }
10534
10535 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
10536 where
10537 V: serde::de::MapAccess<'de>,
10538 {
10539 let mut compact_task__ = None;
10540 let mut table_stats_change__ = None;
10541 let mut object_timestamps__ = None;
10542 while let Some(k) = map_.next_key()? {
10543 match k {
10544 GeneratedField::CompactTask => {
10545 if compact_task__.is_some() {
10546 return Err(serde::de::Error::duplicate_field("compactTask"));
10547 }
10548 compact_task__ = map_.next_value()?;
10549 }
10550 GeneratedField::TableStatsChange => {
10551 if table_stats_change__.is_some() {
10552 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
10553 }
10554 table_stats_change__ = Some(
10555 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10556 .into_iter().map(|(k,v)| (k.0, v)).collect()
10557 );
10558 }
10559 GeneratedField::ObjectTimestamps => {
10560 if object_timestamps__.is_some() {
10561 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
10562 }
10563 object_timestamps__ = Some(
10564 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
10565 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
10566 );
10567 }
10568 }
10569 }
10570 Ok(report_compaction_task_request::ReportTask {
10571 compact_task: compact_task__,
10572 table_stats_change: table_stats_change__.unwrap_or_default(),
10573 object_timestamps: object_timestamps__.unwrap_or_default(),
10574 })
10575 }
10576 }
10577 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
10578 }
10579}
10580impl serde::Serialize for ReportCompactionTaskResponse {
10581 #[allow(deprecated)]
10582 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10583 where
10584 S: serde::Serializer,
10585 {
10586 use serde::ser::SerializeStruct;
10587 let mut len = 0;
10588 if self.status.is_some() {
10589 len += 1;
10590 }
10591 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
10592 if let Some(v) = self.status.as_ref() {
10593 struct_ser.serialize_field("status", v)?;
10594 }
10595 struct_ser.end()
10596 }
10597}
10598impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
10599 #[allow(deprecated)]
10600 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10601 where
10602 D: serde::Deserializer<'de>,
10603 {
10604 const FIELDS: &[&str] = &[
10605 "status",
10606 ];
10607
10608 #[allow(clippy::enum_variant_names)]
10609 enum GeneratedField {
10610 Status,
10611 }
10612 impl<'de> serde::Deserialize<'de> for GeneratedField {
10613 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10614 where
10615 D: serde::Deserializer<'de>,
10616 {
10617 struct GeneratedVisitor;
10618
10619 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10620 type Value = GeneratedField;
10621
10622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10623 write!(formatter, "expected one of: {:?}", &FIELDS)
10624 }
10625
10626 #[allow(unused_variables)]
10627 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10628 where
10629 E: serde::de::Error,
10630 {
10631 match value {
10632 "status" => Ok(GeneratedField::Status),
10633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10634 }
10635 }
10636 }
10637 deserializer.deserialize_identifier(GeneratedVisitor)
10638 }
10639 }
10640 struct GeneratedVisitor;
10641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10642 type Value = ReportCompactionTaskResponse;
10643
10644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10645 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
10646 }
10647
10648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
10649 where
10650 V: serde::de::MapAccess<'de>,
10651 {
10652 let mut status__ = None;
10653 while let Some(k) = map_.next_key()? {
10654 match k {
10655 GeneratedField::Status => {
10656 if status__.is_some() {
10657 return Err(serde::de::Error::duplicate_field("status"));
10658 }
10659 status__ = map_.next_value()?;
10660 }
10661 }
10662 }
10663 Ok(ReportCompactionTaskResponse {
10664 status: status__,
10665 })
10666 }
10667 }
10668 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
10669 }
10670}
10671impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
10672 #[allow(deprecated)]
10673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10674 where
10675 S: serde::Serializer,
10676 {
10677 use serde::ser::SerializeStruct;
10678 let len = 0;
10679 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
10680 struct_ser.end()
10681 }
10682}
10683impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
10684 #[allow(deprecated)]
10685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10686 where
10687 D: serde::Deserializer<'de>,
10688 {
10689 const FIELDS: &[&str] = &[
10690 ];
10691
10692 #[allow(clippy::enum_variant_names)]
10693 enum GeneratedField {
10694 }
10695 impl<'de> serde::Deserialize<'de> for GeneratedField {
10696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10697 where
10698 D: serde::Deserializer<'de>,
10699 {
10700 struct GeneratedVisitor;
10701
10702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10703 type Value = GeneratedField;
10704
10705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10706 write!(formatter, "expected one of: {:?}", &FIELDS)
10707 }
10708
10709 #[allow(unused_variables)]
10710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10711 where
10712 E: serde::de::Error,
10713 {
10714 Err(serde::de::Error::unknown_field(value, FIELDS))
10715 }
10716 }
10717 deserializer.deserialize_identifier(GeneratedVisitor)
10718 }
10719 }
10720 struct GeneratedVisitor;
10721 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10722 type Value = RiseCtlGetCheckpointVersionRequest;
10723
10724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10725 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
10726 }
10727
10728 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
10729 where
10730 V: serde::de::MapAccess<'de>,
10731 {
10732 while map_.next_key::<GeneratedField>()?.is_some() {
10733 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10734 }
10735 Ok(RiseCtlGetCheckpointVersionRequest {
10736 })
10737 }
10738 }
10739 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
10740 }
10741}
10742impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
10743 #[allow(deprecated)]
10744 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10745 where
10746 S: serde::Serializer,
10747 {
10748 use serde::ser::SerializeStruct;
10749 let mut len = 0;
10750 if self.checkpoint_version.is_some() {
10751 len += 1;
10752 }
10753 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
10754 if let Some(v) = self.checkpoint_version.as_ref() {
10755 struct_ser.serialize_field("checkpointVersion", v)?;
10756 }
10757 struct_ser.end()
10758 }
10759}
10760impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
10761 #[allow(deprecated)]
10762 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10763 where
10764 D: serde::Deserializer<'de>,
10765 {
10766 const FIELDS: &[&str] = &[
10767 "checkpoint_version",
10768 "checkpointVersion",
10769 ];
10770
10771 #[allow(clippy::enum_variant_names)]
10772 enum GeneratedField {
10773 CheckpointVersion,
10774 }
10775 impl<'de> serde::Deserialize<'de> for GeneratedField {
10776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10777 where
10778 D: serde::Deserializer<'de>,
10779 {
10780 struct GeneratedVisitor;
10781
10782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10783 type Value = GeneratedField;
10784
10785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10786 write!(formatter, "expected one of: {:?}", &FIELDS)
10787 }
10788
10789 #[allow(unused_variables)]
10790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10791 where
10792 E: serde::de::Error,
10793 {
10794 match value {
10795 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
10796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10797 }
10798 }
10799 }
10800 deserializer.deserialize_identifier(GeneratedVisitor)
10801 }
10802 }
10803 struct GeneratedVisitor;
10804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10805 type Value = RiseCtlGetCheckpointVersionResponse;
10806
10807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10808 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
10809 }
10810
10811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
10812 where
10813 V: serde::de::MapAccess<'de>,
10814 {
10815 let mut checkpoint_version__ = None;
10816 while let Some(k) = map_.next_key()? {
10817 match k {
10818 GeneratedField::CheckpointVersion => {
10819 if checkpoint_version__.is_some() {
10820 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
10821 }
10822 checkpoint_version__ = map_.next_value()?;
10823 }
10824 }
10825 }
10826 Ok(RiseCtlGetCheckpointVersionResponse {
10827 checkpoint_version: checkpoint_version__,
10828 })
10829 }
10830 }
10831 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
10832 }
10833}
10834impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
10835 #[allow(deprecated)]
10836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10837 where
10838 S: serde::Serializer,
10839 {
10840 use serde::ser::SerializeStruct;
10841 let len = 0;
10842 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
10843 struct_ser.end()
10844 }
10845}
10846impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
10847 #[allow(deprecated)]
10848 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10849 where
10850 D: serde::Deserializer<'de>,
10851 {
10852 const FIELDS: &[&str] = &[
10853 ];
10854
10855 #[allow(clippy::enum_variant_names)]
10856 enum GeneratedField {
10857 }
10858 impl<'de> serde::Deserialize<'de> for GeneratedField {
10859 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10860 where
10861 D: serde::Deserializer<'de>,
10862 {
10863 struct GeneratedVisitor;
10864
10865 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10866 type Value = GeneratedField;
10867
10868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10869 write!(formatter, "expected one of: {:?}", &FIELDS)
10870 }
10871
10872 #[allow(unused_variables)]
10873 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10874 where
10875 E: serde::de::Error,
10876 {
10877 Err(serde::de::Error::unknown_field(value, FIELDS))
10878 }
10879 }
10880 deserializer.deserialize_identifier(GeneratedVisitor)
10881 }
10882 }
10883 struct GeneratedVisitor;
10884 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10885 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
10886
10887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10888 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
10889 }
10890
10891 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
10892 where
10893 V: serde::de::MapAccess<'de>,
10894 {
10895 while map_.next_key::<GeneratedField>()?.is_some() {
10896 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10897 }
10898 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
10899 })
10900 }
10901 }
10902 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
10903 }
10904}
10905impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
10906 #[allow(deprecated)]
10907 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10908 where
10909 S: serde::Serializer,
10910 {
10911 use serde::ser::SerializeStruct;
10912 let mut len = 0;
10913 if self.summary.is_some() {
10914 len += 1;
10915 }
10916 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
10917 if let Some(v) = self.summary.as_ref() {
10918 struct_ser.serialize_field("summary", v)?;
10919 }
10920 struct_ser.end()
10921 }
10922}
10923impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
10924 #[allow(deprecated)]
10925 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10926 where
10927 D: serde::Deserializer<'de>,
10928 {
10929 const FIELDS: &[&str] = &[
10930 "summary",
10931 ];
10932
10933 #[allow(clippy::enum_variant_names)]
10934 enum GeneratedField {
10935 Summary,
10936 }
10937 impl<'de> serde::Deserialize<'de> for GeneratedField {
10938 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10939 where
10940 D: serde::Deserializer<'de>,
10941 {
10942 struct GeneratedVisitor;
10943
10944 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10945 type Value = GeneratedField;
10946
10947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10948 write!(formatter, "expected one of: {:?}", &FIELDS)
10949 }
10950
10951 #[allow(unused_variables)]
10952 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10953 where
10954 E: serde::de::Error,
10955 {
10956 match value {
10957 "summary" => Ok(GeneratedField::Summary),
10958 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10959 }
10960 }
10961 }
10962 deserializer.deserialize_identifier(GeneratedVisitor)
10963 }
10964 }
10965 struct GeneratedVisitor;
10966 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10967 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
10968
10969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10970 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
10971 }
10972
10973 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
10974 where
10975 V: serde::de::MapAccess<'de>,
10976 {
10977 let mut summary__ = None;
10978 while let Some(k) = map_.next_key()? {
10979 match k {
10980 GeneratedField::Summary => {
10981 if summary__.is_some() {
10982 return Err(serde::de::Error::duplicate_field("summary"));
10983 }
10984 summary__ = map_.next_value()?;
10985 }
10986 }
10987 }
10988 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
10989 summary: summary__,
10990 })
10991 }
10992 }
10993 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
10994 }
10995}
10996impl serde::Serialize for RiseCtlListCompactionGroupRequest {
10997 #[allow(deprecated)]
10998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10999 where
11000 S: serde::Serializer,
11001 {
11002 use serde::ser::SerializeStruct;
11003 let len = 0;
11004 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
11005 struct_ser.end()
11006 }
11007}
11008impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
11009 #[allow(deprecated)]
11010 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11011 where
11012 D: serde::Deserializer<'de>,
11013 {
11014 const FIELDS: &[&str] = &[
11015 ];
11016
11017 #[allow(clippy::enum_variant_names)]
11018 enum GeneratedField {
11019 }
11020 impl<'de> serde::Deserialize<'de> for GeneratedField {
11021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11022 where
11023 D: serde::Deserializer<'de>,
11024 {
11025 struct GeneratedVisitor;
11026
11027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11028 type Value = GeneratedField;
11029
11030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11031 write!(formatter, "expected one of: {:?}", &FIELDS)
11032 }
11033
11034 #[allow(unused_variables)]
11035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11036 where
11037 E: serde::de::Error,
11038 {
11039 Err(serde::de::Error::unknown_field(value, FIELDS))
11040 }
11041 }
11042 deserializer.deserialize_identifier(GeneratedVisitor)
11043 }
11044 }
11045 struct GeneratedVisitor;
11046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11047 type Value = RiseCtlListCompactionGroupRequest;
11048
11049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11050 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
11051 }
11052
11053 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
11054 where
11055 V: serde::de::MapAccess<'de>,
11056 {
11057 while map_.next_key::<GeneratedField>()?.is_some() {
11058 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11059 }
11060 Ok(RiseCtlListCompactionGroupRequest {
11061 })
11062 }
11063 }
11064 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
11065 }
11066}
11067impl serde::Serialize for RiseCtlListCompactionGroupResponse {
11068 #[allow(deprecated)]
11069 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11070 where
11071 S: serde::Serializer,
11072 {
11073 use serde::ser::SerializeStruct;
11074 let mut len = 0;
11075 if self.status.is_some() {
11076 len += 1;
11077 }
11078 if !self.compaction_groups.is_empty() {
11079 len += 1;
11080 }
11081 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
11082 if let Some(v) = self.status.as_ref() {
11083 struct_ser.serialize_field("status", v)?;
11084 }
11085 if !self.compaction_groups.is_empty() {
11086 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
11087 }
11088 struct_ser.end()
11089 }
11090}
11091impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
11092 #[allow(deprecated)]
11093 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11094 where
11095 D: serde::Deserializer<'de>,
11096 {
11097 const FIELDS: &[&str] = &[
11098 "status",
11099 "compaction_groups",
11100 "compactionGroups",
11101 ];
11102
11103 #[allow(clippy::enum_variant_names)]
11104 enum GeneratedField {
11105 Status,
11106 CompactionGroups,
11107 }
11108 impl<'de> serde::Deserialize<'de> for GeneratedField {
11109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11110 where
11111 D: serde::Deserializer<'de>,
11112 {
11113 struct GeneratedVisitor;
11114
11115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11116 type Value = GeneratedField;
11117
11118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11119 write!(formatter, "expected one of: {:?}", &FIELDS)
11120 }
11121
11122 #[allow(unused_variables)]
11123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11124 where
11125 E: serde::de::Error,
11126 {
11127 match value {
11128 "status" => Ok(GeneratedField::Status),
11129 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
11130 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11131 }
11132 }
11133 }
11134 deserializer.deserialize_identifier(GeneratedVisitor)
11135 }
11136 }
11137 struct GeneratedVisitor;
11138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11139 type Value = RiseCtlListCompactionGroupResponse;
11140
11141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11142 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
11143 }
11144
11145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
11146 where
11147 V: serde::de::MapAccess<'de>,
11148 {
11149 let mut status__ = None;
11150 let mut compaction_groups__ = None;
11151 while let Some(k) = map_.next_key()? {
11152 match k {
11153 GeneratedField::Status => {
11154 if status__.is_some() {
11155 return Err(serde::de::Error::duplicate_field("status"));
11156 }
11157 status__ = map_.next_value()?;
11158 }
11159 GeneratedField::CompactionGroups => {
11160 if compaction_groups__.is_some() {
11161 return Err(serde::de::Error::duplicate_field("compactionGroups"));
11162 }
11163 compaction_groups__ = Some(map_.next_value()?);
11164 }
11165 }
11166 }
11167 Ok(RiseCtlListCompactionGroupResponse {
11168 status: status__,
11169 compaction_groups: compaction_groups__.unwrap_or_default(),
11170 })
11171 }
11172 }
11173 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
11174 }
11175}
11176impl serde::Serialize for RiseCtlListCompactionStatusRequest {
11177 #[allow(deprecated)]
11178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11179 where
11180 S: serde::Serializer,
11181 {
11182 use serde::ser::SerializeStruct;
11183 let len = 0;
11184 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
11185 struct_ser.end()
11186 }
11187}
11188impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
11189 #[allow(deprecated)]
11190 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11191 where
11192 D: serde::Deserializer<'de>,
11193 {
11194 const FIELDS: &[&str] = &[
11195 ];
11196
11197 #[allow(clippy::enum_variant_names)]
11198 enum GeneratedField {
11199 }
11200 impl<'de> serde::Deserialize<'de> for GeneratedField {
11201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11202 where
11203 D: serde::Deserializer<'de>,
11204 {
11205 struct GeneratedVisitor;
11206
11207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11208 type Value = GeneratedField;
11209
11210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11211 write!(formatter, "expected one of: {:?}", &FIELDS)
11212 }
11213
11214 #[allow(unused_variables)]
11215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11216 where
11217 E: serde::de::Error,
11218 {
11219 Err(serde::de::Error::unknown_field(value, FIELDS))
11220 }
11221 }
11222 deserializer.deserialize_identifier(GeneratedVisitor)
11223 }
11224 }
11225 struct GeneratedVisitor;
11226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11227 type Value = RiseCtlListCompactionStatusRequest;
11228
11229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11230 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
11231 }
11232
11233 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
11234 where
11235 V: serde::de::MapAccess<'de>,
11236 {
11237 while map_.next_key::<GeneratedField>()?.is_some() {
11238 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11239 }
11240 Ok(RiseCtlListCompactionStatusRequest {
11241 })
11242 }
11243 }
11244 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
11245 }
11246}
11247impl serde::Serialize for RiseCtlListCompactionStatusResponse {
11248 #[allow(deprecated)]
11249 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11250 where
11251 S: serde::Serializer,
11252 {
11253 use serde::ser::SerializeStruct;
11254 let mut len = 0;
11255 if !self.compaction_statuses.is_empty() {
11256 len += 1;
11257 }
11258 if !self.task_assignment.is_empty() {
11259 len += 1;
11260 }
11261 if !self.task_progress.is_empty() {
11262 len += 1;
11263 }
11264 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
11265 if !self.compaction_statuses.is_empty() {
11266 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
11267 }
11268 if !self.task_assignment.is_empty() {
11269 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
11270 }
11271 if !self.task_progress.is_empty() {
11272 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
11273 }
11274 struct_ser.end()
11275 }
11276}
11277impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
11278 #[allow(deprecated)]
11279 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11280 where
11281 D: serde::Deserializer<'de>,
11282 {
11283 const FIELDS: &[&str] = &[
11284 "compaction_statuses",
11285 "compactionStatuses",
11286 "task_assignment",
11287 "taskAssignment",
11288 "task_progress",
11289 "taskProgress",
11290 ];
11291
11292 #[allow(clippy::enum_variant_names)]
11293 enum GeneratedField {
11294 CompactionStatuses,
11295 TaskAssignment,
11296 TaskProgress,
11297 }
11298 impl<'de> serde::Deserialize<'de> for GeneratedField {
11299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11300 where
11301 D: serde::Deserializer<'de>,
11302 {
11303 struct GeneratedVisitor;
11304
11305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11306 type Value = GeneratedField;
11307
11308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11309 write!(formatter, "expected one of: {:?}", &FIELDS)
11310 }
11311
11312 #[allow(unused_variables)]
11313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11314 where
11315 E: serde::de::Error,
11316 {
11317 match value {
11318 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
11319 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
11320 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
11321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11322 }
11323 }
11324 }
11325 deserializer.deserialize_identifier(GeneratedVisitor)
11326 }
11327 }
11328 struct GeneratedVisitor;
11329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11330 type Value = RiseCtlListCompactionStatusResponse;
11331
11332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11333 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
11334 }
11335
11336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
11337 where
11338 V: serde::de::MapAccess<'de>,
11339 {
11340 let mut compaction_statuses__ = None;
11341 let mut task_assignment__ = None;
11342 let mut task_progress__ = None;
11343 while let Some(k) = map_.next_key()? {
11344 match k {
11345 GeneratedField::CompactionStatuses => {
11346 if compaction_statuses__.is_some() {
11347 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
11348 }
11349 compaction_statuses__ = Some(map_.next_value()?);
11350 }
11351 GeneratedField::TaskAssignment => {
11352 if task_assignment__.is_some() {
11353 return Err(serde::de::Error::duplicate_field("taskAssignment"));
11354 }
11355 task_assignment__ = Some(map_.next_value()?);
11356 }
11357 GeneratedField::TaskProgress => {
11358 if task_progress__.is_some() {
11359 return Err(serde::de::Error::duplicate_field("taskProgress"));
11360 }
11361 task_progress__ = Some(map_.next_value()?);
11362 }
11363 }
11364 }
11365 Ok(RiseCtlListCompactionStatusResponse {
11366 compaction_statuses: compaction_statuses__.unwrap_or_default(),
11367 task_assignment: task_assignment__.unwrap_or_default(),
11368 task_progress: task_progress__.unwrap_or_default(),
11369 })
11370 }
11371 }
11372 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
11373 }
11374}
11375impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
11376 #[allow(deprecated)]
11377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11378 where
11379 S: serde::Serializer,
11380 {
11381 use serde::ser::SerializeStruct;
11382 let len = 0;
11383 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
11384 struct_ser.end()
11385 }
11386}
11387impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
11388 #[allow(deprecated)]
11389 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11390 where
11391 D: serde::Deserializer<'de>,
11392 {
11393 const FIELDS: &[&str] = &[
11394 ];
11395
11396 #[allow(clippy::enum_variant_names)]
11397 enum GeneratedField {
11398 }
11399 impl<'de> serde::Deserialize<'de> for GeneratedField {
11400 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11401 where
11402 D: serde::Deserializer<'de>,
11403 {
11404 struct GeneratedVisitor;
11405
11406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11407 type Value = GeneratedField;
11408
11409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11410 write!(formatter, "expected one of: {:?}", &FIELDS)
11411 }
11412
11413 #[allow(unused_variables)]
11414 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11415 where
11416 E: serde::de::Error,
11417 {
11418 Err(serde::de::Error::unknown_field(value, FIELDS))
11419 }
11420 }
11421 deserializer.deserialize_identifier(GeneratedVisitor)
11422 }
11423 }
11424 struct GeneratedVisitor;
11425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11426 type Value = RiseCtlPauseVersionCheckpointRequest;
11427
11428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11429 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
11430 }
11431
11432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
11433 where
11434 V: serde::de::MapAccess<'de>,
11435 {
11436 while map_.next_key::<GeneratedField>()?.is_some() {
11437 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11438 }
11439 Ok(RiseCtlPauseVersionCheckpointRequest {
11440 })
11441 }
11442 }
11443 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11444 }
11445}
11446impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
11447 #[allow(deprecated)]
11448 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11449 where
11450 S: serde::Serializer,
11451 {
11452 use serde::ser::SerializeStruct;
11453 let len = 0;
11454 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
11455 struct_ser.end()
11456 }
11457}
11458impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
11459 #[allow(deprecated)]
11460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11461 where
11462 D: serde::Deserializer<'de>,
11463 {
11464 const FIELDS: &[&str] = &[
11465 ];
11466
11467 #[allow(clippy::enum_variant_names)]
11468 enum GeneratedField {
11469 }
11470 impl<'de> serde::Deserialize<'de> for GeneratedField {
11471 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11472 where
11473 D: serde::Deserializer<'de>,
11474 {
11475 struct GeneratedVisitor;
11476
11477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11478 type Value = GeneratedField;
11479
11480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11481 write!(formatter, "expected one of: {:?}", &FIELDS)
11482 }
11483
11484 #[allow(unused_variables)]
11485 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11486 where
11487 E: serde::de::Error,
11488 {
11489 Err(serde::de::Error::unknown_field(value, FIELDS))
11490 }
11491 }
11492 deserializer.deserialize_identifier(GeneratedVisitor)
11493 }
11494 }
11495 struct GeneratedVisitor;
11496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11497 type Value = RiseCtlPauseVersionCheckpointResponse;
11498
11499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11500 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
11501 }
11502
11503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
11504 where
11505 V: serde::de::MapAccess<'de>,
11506 {
11507 while map_.next_key::<GeneratedField>()?.is_some() {
11508 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11509 }
11510 Ok(RiseCtlPauseVersionCheckpointResponse {
11511 })
11512 }
11513 }
11514 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11515 }
11516}
11517impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
11518 #[allow(deprecated)]
11519 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11520 where
11521 S: serde::Serializer,
11522 {
11523 use serde::ser::SerializeStruct;
11524 let len = 0;
11525 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
11526 struct_ser.end()
11527 }
11528}
11529impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
11530 #[allow(deprecated)]
11531 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11532 where
11533 D: serde::Deserializer<'de>,
11534 {
11535 const FIELDS: &[&str] = &[
11536 ];
11537
11538 #[allow(clippy::enum_variant_names)]
11539 enum GeneratedField {
11540 }
11541 impl<'de> serde::Deserialize<'de> for GeneratedField {
11542 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11543 where
11544 D: serde::Deserializer<'de>,
11545 {
11546 struct GeneratedVisitor;
11547
11548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11549 type Value = GeneratedField;
11550
11551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11552 write!(formatter, "expected one of: {:?}", &FIELDS)
11553 }
11554
11555 #[allow(unused_variables)]
11556 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11557 where
11558 E: serde::de::Error,
11559 {
11560 Err(serde::de::Error::unknown_field(value, FIELDS))
11561 }
11562 }
11563 deserializer.deserialize_identifier(GeneratedVisitor)
11564 }
11565 }
11566 struct GeneratedVisitor;
11567 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11568 type Value = RiseCtlRebuildTableStatsRequest;
11569
11570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11571 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
11572 }
11573
11574 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
11575 where
11576 V: serde::de::MapAccess<'de>,
11577 {
11578 while map_.next_key::<GeneratedField>()?.is_some() {
11579 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11580 }
11581 Ok(RiseCtlRebuildTableStatsRequest {
11582 })
11583 }
11584 }
11585 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
11586 }
11587}
11588impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
11589 #[allow(deprecated)]
11590 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11591 where
11592 S: serde::Serializer,
11593 {
11594 use serde::ser::SerializeStruct;
11595 let len = 0;
11596 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
11597 struct_ser.end()
11598 }
11599}
11600impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
11601 #[allow(deprecated)]
11602 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11603 where
11604 D: serde::Deserializer<'de>,
11605 {
11606 const FIELDS: &[&str] = &[
11607 ];
11608
11609 #[allow(clippy::enum_variant_names)]
11610 enum GeneratedField {
11611 }
11612 impl<'de> serde::Deserialize<'de> for GeneratedField {
11613 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11614 where
11615 D: serde::Deserializer<'de>,
11616 {
11617 struct GeneratedVisitor;
11618
11619 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11620 type Value = GeneratedField;
11621
11622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11623 write!(formatter, "expected one of: {:?}", &FIELDS)
11624 }
11625
11626 #[allow(unused_variables)]
11627 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11628 where
11629 E: serde::de::Error,
11630 {
11631 Err(serde::de::Error::unknown_field(value, FIELDS))
11632 }
11633 }
11634 deserializer.deserialize_identifier(GeneratedVisitor)
11635 }
11636 }
11637 struct GeneratedVisitor;
11638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11639 type Value = RiseCtlRebuildTableStatsResponse;
11640
11641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11642 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
11643 }
11644
11645 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
11646 where
11647 V: serde::de::MapAccess<'de>,
11648 {
11649 while map_.next_key::<GeneratedField>()?.is_some() {
11650 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11651 }
11652 Ok(RiseCtlRebuildTableStatsResponse {
11653 })
11654 }
11655 }
11656 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
11657 }
11658}
11659impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
11660 #[allow(deprecated)]
11661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11662 where
11663 S: serde::Serializer,
11664 {
11665 use serde::ser::SerializeStruct;
11666 let len = 0;
11667 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
11668 struct_ser.end()
11669 }
11670}
11671impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
11672 #[allow(deprecated)]
11673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11674 where
11675 D: serde::Deserializer<'de>,
11676 {
11677 const FIELDS: &[&str] = &[
11678 ];
11679
11680 #[allow(clippy::enum_variant_names)]
11681 enum GeneratedField {
11682 }
11683 impl<'de> serde::Deserialize<'de> for GeneratedField {
11684 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11685 where
11686 D: serde::Deserializer<'de>,
11687 {
11688 struct GeneratedVisitor;
11689
11690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11691 type Value = GeneratedField;
11692
11693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11694 write!(formatter, "expected one of: {:?}", &FIELDS)
11695 }
11696
11697 #[allow(unused_variables)]
11698 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11699 where
11700 E: serde::de::Error,
11701 {
11702 Err(serde::de::Error::unknown_field(value, FIELDS))
11703 }
11704 }
11705 deserializer.deserialize_identifier(GeneratedVisitor)
11706 }
11707 }
11708 struct GeneratedVisitor;
11709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11710 type Value = RiseCtlResumeVersionCheckpointRequest;
11711
11712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11713 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
11714 }
11715
11716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
11717 where
11718 V: serde::de::MapAccess<'de>,
11719 {
11720 while map_.next_key::<GeneratedField>()?.is_some() {
11721 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11722 }
11723 Ok(RiseCtlResumeVersionCheckpointRequest {
11724 })
11725 }
11726 }
11727 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11728 }
11729}
11730impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
11731 #[allow(deprecated)]
11732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11733 where
11734 S: serde::Serializer,
11735 {
11736 use serde::ser::SerializeStruct;
11737 let len = 0;
11738 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
11739 struct_ser.end()
11740 }
11741}
11742impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
11743 #[allow(deprecated)]
11744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11745 where
11746 D: serde::Deserializer<'de>,
11747 {
11748 const FIELDS: &[&str] = &[
11749 ];
11750
11751 #[allow(clippy::enum_variant_names)]
11752 enum GeneratedField {
11753 }
11754 impl<'de> serde::Deserialize<'de> for GeneratedField {
11755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11756 where
11757 D: serde::Deserializer<'de>,
11758 {
11759 struct GeneratedVisitor;
11760
11761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11762 type Value = GeneratedField;
11763
11764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11765 write!(formatter, "expected one of: {:?}", &FIELDS)
11766 }
11767
11768 #[allow(unused_variables)]
11769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11770 where
11771 E: serde::de::Error,
11772 {
11773 Err(serde::de::Error::unknown_field(value, FIELDS))
11774 }
11775 }
11776 deserializer.deserialize_identifier(GeneratedVisitor)
11777 }
11778 }
11779 struct GeneratedVisitor;
11780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11781 type Value = RiseCtlResumeVersionCheckpointResponse;
11782
11783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11784 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
11785 }
11786
11787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
11788 where
11789 V: serde::de::MapAccess<'de>,
11790 {
11791 while map_.next_key::<GeneratedField>()?.is_some() {
11792 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11793 }
11794 Ok(RiseCtlResumeVersionCheckpointResponse {
11795 })
11796 }
11797 }
11798 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11799 }
11800}
11801impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
11802 #[allow(deprecated)]
11803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11804 where
11805 S: serde::Serializer,
11806 {
11807 use serde::ser::SerializeStruct;
11808 let mut len = 0;
11809 if !self.compaction_group_ids.is_empty() {
11810 len += 1;
11811 }
11812 if !self.configs.is_empty() {
11813 len += 1;
11814 }
11815 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
11816 if !self.compaction_group_ids.is_empty() {
11817 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
11818 }
11819 if !self.configs.is_empty() {
11820 struct_ser.serialize_field("configs", &self.configs)?;
11821 }
11822 struct_ser.end()
11823 }
11824}
11825impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
11826 #[allow(deprecated)]
11827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11828 where
11829 D: serde::Deserializer<'de>,
11830 {
11831 const FIELDS: &[&str] = &[
11832 "compaction_group_ids",
11833 "compactionGroupIds",
11834 "configs",
11835 ];
11836
11837 #[allow(clippy::enum_variant_names)]
11838 enum GeneratedField {
11839 CompactionGroupIds,
11840 Configs,
11841 }
11842 impl<'de> serde::Deserialize<'de> for GeneratedField {
11843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11844 where
11845 D: serde::Deserializer<'de>,
11846 {
11847 struct GeneratedVisitor;
11848
11849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11850 type Value = GeneratedField;
11851
11852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11853 write!(formatter, "expected one of: {:?}", &FIELDS)
11854 }
11855
11856 #[allow(unused_variables)]
11857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11858 where
11859 E: serde::de::Error,
11860 {
11861 match value {
11862 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
11863 "configs" => Ok(GeneratedField::Configs),
11864 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11865 }
11866 }
11867 }
11868 deserializer.deserialize_identifier(GeneratedVisitor)
11869 }
11870 }
11871 struct GeneratedVisitor;
11872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11873 type Value = RiseCtlUpdateCompactionConfigRequest;
11874
11875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11876 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
11877 }
11878
11879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
11880 where
11881 V: serde::de::MapAccess<'de>,
11882 {
11883 let mut compaction_group_ids__ = None;
11884 let mut configs__ = None;
11885 while let Some(k) = map_.next_key()? {
11886 match k {
11887 GeneratedField::CompactionGroupIds => {
11888 if compaction_group_ids__.is_some() {
11889 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
11890 }
11891 compaction_group_ids__ =
11892 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11893 .into_iter().map(|x| x.0).collect())
11894 ;
11895 }
11896 GeneratedField::Configs => {
11897 if configs__.is_some() {
11898 return Err(serde::de::Error::duplicate_field("configs"));
11899 }
11900 configs__ = Some(map_.next_value()?);
11901 }
11902 }
11903 }
11904 Ok(RiseCtlUpdateCompactionConfigRequest {
11905 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
11906 configs: configs__.unwrap_or_default(),
11907 })
11908 }
11909 }
11910 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
11911 }
11912}
11913impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11914 #[allow(deprecated)]
11915 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11916 where
11917 S: serde::Serializer,
11918 {
11919 use serde::ser::SerializeStruct;
11920 let mut len = 0;
11921 if self.level != 0 {
11922 len += 1;
11923 }
11924 if !self.compression_algorithm.is_empty() {
11925 len += 1;
11926 }
11927 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
11928 if self.level != 0 {
11929 struct_ser.serialize_field("level", &self.level)?;
11930 }
11931 if !self.compression_algorithm.is_empty() {
11932 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
11933 }
11934 struct_ser.end()
11935 }
11936}
11937impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11938 #[allow(deprecated)]
11939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11940 where
11941 D: serde::Deserializer<'de>,
11942 {
11943 const FIELDS: &[&str] = &[
11944 "level",
11945 "compression_algorithm",
11946 "compressionAlgorithm",
11947 ];
11948
11949 #[allow(clippy::enum_variant_names)]
11950 enum GeneratedField {
11951 Level,
11952 CompressionAlgorithm,
11953 }
11954 impl<'de> serde::Deserialize<'de> for GeneratedField {
11955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11956 where
11957 D: serde::Deserializer<'de>,
11958 {
11959 struct GeneratedVisitor;
11960
11961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11962 type Value = GeneratedField;
11963
11964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11965 write!(formatter, "expected one of: {:?}", &FIELDS)
11966 }
11967
11968 #[allow(unused_variables)]
11969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11970 where
11971 E: serde::de::Error,
11972 {
11973 match value {
11974 "level" => Ok(GeneratedField::Level),
11975 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
11976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11977 }
11978 }
11979 }
11980 deserializer.deserialize_identifier(GeneratedVisitor)
11981 }
11982 }
11983 struct GeneratedVisitor;
11984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11985 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
11986
11987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11988 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
11989 }
11990
11991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
11992 where
11993 V: serde::de::MapAccess<'de>,
11994 {
11995 let mut level__ = None;
11996 let mut compression_algorithm__ = None;
11997 while let Some(k) = map_.next_key()? {
11998 match k {
11999 GeneratedField::Level => {
12000 if level__.is_some() {
12001 return Err(serde::de::Error::duplicate_field("level"));
12002 }
12003 level__ =
12004 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12005 ;
12006 }
12007 GeneratedField::CompressionAlgorithm => {
12008 if compression_algorithm__.is_some() {
12009 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12010 }
12011 compression_algorithm__ = Some(map_.next_value()?);
12012 }
12013 }
12014 }
12015 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12016 level: level__.unwrap_or_default(),
12017 compression_algorithm: compression_algorithm__.unwrap_or_default(),
12018 })
12019 }
12020 }
12021 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
12022 }
12023}
12024impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
12025 #[allow(deprecated)]
12026 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12027 where
12028 S: serde::Serializer,
12029 {
12030 use serde::ser::SerializeStruct;
12031 let mut len = 0;
12032 if self.mutable_config.is_some() {
12033 len += 1;
12034 }
12035 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
12036 if let Some(v) = self.mutable_config.as_ref() {
12037 match v {
12038 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
12039 #[allow(clippy::needless_borrow)]
12040 #[allow(clippy::needless_borrows_for_generic_args)]
12041 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
12042 }
12043 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
12044 #[allow(clippy::needless_borrow)]
12045 #[allow(clippy::needless_borrows_for_generic_args)]
12046 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
12047 }
12048 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
12049 #[allow(clippy::needless_borrow)]
12050 #[allow(clippy::needless_borrows_for_generic_args)]
12051 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
12052 }
12053 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
12054 #[allow(clippy::needless_borrow)]
12055 #[allow(clippy::needless_borrows_for_generic_args)]
12056 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
12057 }
12058 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
12059 #[allow(clippy::needless_borrow)]
12060 #[allow(clippy::needless_borrows_for_generic_args)]
12061 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
12062 }
12063 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
12064 #[allow(clippy::needless_borrow)]
12065 #[allow(clippy::needless_borrows_for_generic_args)]
12066 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
12067 }
12068 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
12069 struct_ser.serialize_field("compactionFilterMask", v)?;
12070 }
12071 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
12072 struct_ser.serialize_field("maxSubCompaction", v)?;
12073 }
12074 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
12075 #[allow(clippy::needless_borrow)]
12076 #[allow(clippy::needless_borrows_for_generic_args)]
12077 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
12078 }
12079 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
12080 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
12081 }
12082 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
12083 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
12084 }
12085 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
12086 #[allow(clippy::needless_borrow)]
12087 #[allow(clippy::needless_borrows_for_generic_args)]
12088 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
12089 }
12090 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
12091 #[allow(clippy::needless_borrow)]
12092 #[allow(clippy::needless_borrows_for_generic_args)]
12093 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
12094 }
12095 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
12096 struct_ser.serialize_field("enableEmergencyPicker", v)?;
12097 }
12098 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
12099 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
12100 }
12101 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
12102 struct_ser.serialize_field("compressionAlgorithm", v)?;
12103 }
12104 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
12105 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
12106 }
12107 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
12108 #[allow(clippy::needless_borrow)]
12109 #[allow(clippy::needless_borrows_for_generic_args)]
12110 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
12111 }
12112 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
12113 struct_ser.serialize_field("splitWeightByVnode", v)?;
12114 }
12115 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
12116 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
12117 }
12118 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
12119 #[allow(clippy::needless_borrow)]
12120 #[allow(clippy::needless_borrows_for_generic_args)]
12121 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
12122 }
12123 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
12124 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
12125 }
12126 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
12127 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
12128 }
12129 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
12130 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
12131 }
12132 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
12133 #[allow(clippy::needless_borrow)]
12134 #[allow(clippy::needless_borrows_for_generic_args)]
12135 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
12136 }
12137 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
12138 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
12139 }
12140 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
12141 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
12142 }
12143 }
12144 }
12145 struct_ser.end()
12146 }
12147}
12148impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
12149 #[allow(deprecated)]
12150 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12151 where
12152 D: serde::Deserializer<'de>,
12153 {
12154 const FIELDS: &[&str] = &[
12155 "max_bytes_for_level_base",
12156 "maxBytesForLevelBase",
12157 "max_bytes_for_level_multiplier",
12158 "maxBytesForLevelMultiplier",
12159 "max_compaction_bytes",
12160 "maxCompactionBytes",
12161 "sub_level_max_compaction_bytes",
12162 "subLevelMaxCompactionBytes",
12163 "level0_tier_compact_file_number",
12164 "level0TierCompactFileNumber",
12165 "target_file_size_base",
12166 "targetFileSizeBase",
12167 "compaction_filter_mask",
12168 "compactionFilterMask",
12169 "max_sub_compaction",
12170 "maxSubCompaction",
12171 "level0_stop_write_threshold_sub_level_number",
12172 "level0StopWriteThresholdSubLevelNumber",
12173 "level0_sub_level_compact_level_count",
12174 "level0SubLevelCompactLevelCount",
12175 "level0_overlapping_sub_level_compact_level_count",
12176 "level0OverlappingSubLevelCompactLevelCount",
12177 "max_space_reclaim_bytes",
12178 "maxSpaceReclaimBytes",
12179 "level0_max_compact_file_number",
12180 "level0MaxCompactFileNumber",
12181 "enable_emergency_picker",
12182 "enableEmergencyPicker",
12183 "tombstone_reclaim_ratio",
12184 "tombstoneReclaimRatio",
12185 "compression_algorithm",
12186 "compressionAlgorithm",
12187 "max_l0_compact_level_count",
12188 "maxL0CompactLevelCount",
12189 "sst_allowed_trivial_move_min_size",
12190 "sstAllowedTrivialMoveMinSize",
12191 "split_weight_by_vnode",
12192 "splitWeightByVnode",
12193 "disable_auto_group_scheduling",
12194 "disableAutoGroupScheduling",
12195 "max_overlapping_level_size",
12196 "maxOverlappingLevelSize",
12197 "emergency_level0_sst_file_count",
12198 "emergencyLevel0SstFileCount",
12199 "emergency_level0_sub_level_partition",
12200 "emergencyLevel0SubLevelPartition",
12201 "level0_stop_write_threshold_max_sst_count",
12202 "level0StopWriteThresholdMaxSstCount",
12203 "level0_stop_write_threshold_max_size",
12204 "level0StopWriteThresholdMaxSize",
12205 "sst_allowed_trivial_move_max_count",
12206 "sstAllowedTrivialMoveMaxCount",
12207 "enable_optimize_l0_interval_selection",
12208 "enableOptimizeL0IntervalSelection",
12209 ];
12210
12211 #[allow(clippy::enum_variant_names)]
12212 enum GeneratedField {
12213 MaxBytesForLevelBase,
12214 MaxBytesForLevelMultiplier,
12215 MaxCompactionBytes,
12216 SubLevelMaxCompactionBytes,
12217 Level0TierCompactFileNumber,
12218 TargetFileSizeBase,
12219 CompactionFilterMask,
12220 MaxSubCompaction,
12221 Level0StopWriteThresholdSubLevelNumber,
12222 Level0SubLevelCompactLevelCount,
12223 Level0OverlappingSubLevelCompactLevelCount,
12224 MaxSpaceReclaimBytes,
12225 Level0MaxCompactFileNumber,
12226 EnableEmergencyPicker,
12227 TombstoneReclaimRatio,
12228 CompressionAlgorithm,
12229 MaxL0CompactLevelCount,
12230 SstAllowedTrivialMoveMinSize,
12231 SplitWeightByVnode,
12232 DisableAutoGroupScheduling,
12233 MaxOverlappingLevelSize,
12234 EmergencyLevel0SstFileCount,
12235 EmergencyLevel0SubLevelPartition,
12236 Level0StopWriteThresholdMaxSstCount,
12237 Level0StopWriteThresholdMaxSize,
12238 SstAllowedTrivialMoveMaxCount,
12239 EnableOptimizeL0IntervalSelection,
12240 }
12241 impl<'de> serde::Deserialize<'de> for GeneratedField {
12242 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12243 where
12244 D: serde::Deserializer<'de>,
12245 {
12246 struct GeneratedVisitor;
12247
12248 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12249 type Value = GeneratedField;
12250
12251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12252 write!(formatter, "expected one of: {:?}", &FIELDS)
12253 }
12254
12255 #[allow(unused_variables)]
12256 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12257 where
12258 E: serde::de::Error,
12259 {
12260 match value {
12261 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
12262 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
12263 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
12264 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
12265 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
12266 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
12267 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
12268 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
12269 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
12270 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
12271 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
12272 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
12273 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
12274 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
12275 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
12276 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12277 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
12278 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
12279 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
12280 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
12281 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
12282 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
12283 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
12284 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
12285 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
12286 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
12287 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
12288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12289 }
12290 }
12291 }
12292 deserializer.deserialize_identifier(GeneratedVisitor)
12293 }
12294 }
12295 struct GeneratedVisitor;
12296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12297 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
12298
12299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12300 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
12301 }
12302
12303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
12304 where
12305 V: serde::de::MapAccess<'de>,
12306 {
12307 let mut mutable_config__ = None;
12308 while let Some(k) = map_.next_key()? {
12309 match k {
12310 GeneratedField::MaxBytesForLevelBase => {
12311 if mutable_config__.is_some() {
12312 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
12313 }
12314 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));
12315 }
12316 GeneratedField::MaxBytesForLevelMultiplier => {
12317 if mutable_config__.is_some() {
12318 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
12319 }
12320 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));
12321 }
12322 GeneratedField::MaxCompactionBytes => {
12323 if mutable_config__.is_some() {
12324 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
12325 }
12326 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));
12327 }
12328 GeneratedField::SubLevelMaxCompactionBytes => {
12329 if mutable_config__.is_some() {
12330 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
12331 }
12332 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));
12333 }
12334 GeneratedField::Level0TierCompactFileNumber => {
12335 if mutable_config__.is_some() {
12336 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
12337 }
12338 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));
12339 }
12340 GeneratedField::TargetFileSizeBase => {
12341 if mutable_config__.is_some() {
12342 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
12343 }
12344 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));
12345 }
12346 GeneratedField::CompactionFilterMask => {
12347 if mutable_config__.is_some() {
12348 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
12349 }
12350 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));
12351 }
12352 GeneratedField::MaxSubCompaction => {
12353 if mutable_config__.is_some() {
12354 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
12355 }
12356 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));
12357 }
12358 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
12359 if mutable_config__.is_some() {
12360 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
12361 }
12362 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));
12363 }
12364 GeneratedField::Level0SubLevelCompactLevelCount => {
12365 if mutable_config__.is_some() {
12366 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
12367 }
12368 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));
12369 }
12370 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
12371 if mutable_config__.is_some() {
12372 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
12373 }
12374 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));
12375 }
12376 GeneratedField::MaxSpaceReclaimBytes => {
12377 if mutable_config__.is_some() {
12378 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
12379 }
12380 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));
12381 }
12382 GeneratedField::Level0MaxCompactFileNumber => {
12383 if mutable_config__.is_some() {
12384 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
12385 }
12386 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));
12387 }
12388 GeneratedField::EnableEmergencyPicker => {
12389 if mutable_config__.is_some() {
12390 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
12391 }
12392 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
12393 }
12394 GeneratedField::TombstoneReclaimRatio => {
12395 if mutable_config__.is_some() {
12396 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
12397 }
12398 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));
12399 }
12400 GeneratedField::CompressionAlgorithm => {
12401 if mutable_config__.is_some() {
12402 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12403 }
12404 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
12405;
12406 }
12407 GeneratedField::MaxL0CompactLevelCount => {
12408 if mutable_config__.is_some() {
12409 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
12410 }
12411 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));
12412 }
12413 GeneratedField::SstAllowedTrivialMoveMinSize => {
12414 if mutable_config__.is_some() {
12415 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
12416 }
12417 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));
12418 }
12419 GeneratedField::SplitWeightByVnode => {
12420 if mutable_config__.is_some() {
12421 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
12422 }
12423 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));
12424 }
12425 GeneratedField::DisableAutoGroupScheduling => {
12426 if mutable_config__.is_some() {
12427 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
12428 }
12429 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
12430 }
12431 GeneratedField::MaxOverlappingLevelSize => {
12432 if mutable_config__.is_some() {
12433 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
12434 }
12435 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));
12436 }
12437 GeneratedField::EmergencyLevel0SstFileCount => {
12438 if mutable_config__.is_some() {
12439 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
12440 }
12441 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));
12442 }
12443 GeneratedField::EmergencyLevel0SubLevelPartition => {
12444 if mutable_config__.is_some() {
12445 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
12446 }
12447 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));
12448 }
12449 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
12450 if mutable_config__.is_some() {
12451 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
12452 }
12453 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));
12454 }
12455 GeneratedField::Level0StopWriteThresholdMaxSize => {
12456 if mutable_config__.is_some() {
12457 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
12458 }
12459 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));
12460 }
12461 GeneratedField::SstAllowedTrivialMoveMaxCount => {
12462 if mutable_config__.is_some() {
12463 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
12464 }
12465 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));
12466 }
12467 GeneratedField::EnableOptimizeL0IntervalSelection => {
12468 if mutable_config__.is_some() {
12469 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
12470 }
12471 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
12472 }
12473 }
12474 }
12475 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
12476 mutable_config: mutable_config__,
12477 })
12478 }
12479 }
12480 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
12481 }
12482}
12483impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
12484 #[allow(deprecated)]
12485 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12486 where
12487 S: serde::Serializer,
12488 {
12489 use serde::ser::SerializeStruct;
12490 let mut len = 0;
12491 if self.status.is_some() {
12492 len += 1;
12493 }
12494 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
12495 if let Some(v) = self.status.as_ref() {
12496 struct_ser.serialize_field("status", v)?;
12497 }
12498 struct_ser.end()
12499 }
12500}
12501impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
12502 #[allow(deprecated)]
12503 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12504 where
12505 D: serde::Deserializer<'de>,
12506 {
12507 const FIELDS: &[&str] = &[
12508 "status",
12509 ];
12510
12511 #[allow(clippy::enum_variant_names)]
12512 enum GeneratedField {
12513 Status,
12514 }
12515 impl<'de> serde::Deserialize<'de> for GeneratedField {
12516 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12517 where
12518 D: serde::Deserializer<'de>,
12519 {
12520 struct GeneratedVisitor;
12521
12522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12523 type Value = GeneratedField;
12524
12525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12526 write!(formatter, "expected one of: {:?}", &FIELDS)
12527 }
12528
12529 #[allow(unused_variables)]
12530 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12531 where
12532 E: serde::de::Error,
12533 {
12534 match value {
12535 "status" => Ok(GeneratedField::Status),
12536 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12537 }
12538 }
12539 }
12540 deserializer.deserialize_identifier(GeneratedVisitor)
12541 }
12542 }
12543 struct GeneratedVisitor;
12544 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12545 type Value = RiseCtlUpdateCompactionConfigResponse;
12546
12547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12548 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
12549 }
12550
12551 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
12552 where
12553 V: serde::de::MapAccess<'de>,
12554 {
12555 let mut status__ = None;
12556 while let Some(k) = map_.next_key()? {
12557 match k {
12558 GeneratedField::Status => {
12559 if status__.is_some() {
12560 return Err(serde::de::Error::duplicate_field("status"));
12561 }
12562 status__ = map_.next_value()?;
12563 }
12564 }
12565 }
12566 Ok(RiseCtlUpdateCompactionConfigResponse {
12567 status: status__,
12568 })
12569 }
12570 }
12571 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
12572 }
12573}
12574impl serde::Serialize for SplitCompactionGroupRequest {
12575 #[allow(deprecated)]
12576 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12577 where
12578 S: serde::Serializer,
12579 {
12580 use serde::ser::SerializeStruct;
12581 let mut len = 0;
12582 if self.group_id != 0 {
12583 len += 1;
12584 }
12585 if !self.table_ids.is_empty() {
12586 len += 1;
12587 }
12588 if self.partition_vnode_count != 0 {
12589 len += 1;
12590 }
12591 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
12592 if self.group_id != 0 {
12593 #[allow(clippy::needless_borrow)]
12594 #[allow(clippy::needless_borrows_for_generic_args)]
12595 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
12596 }
12597 if !self.table_ids.is_empty() {
12598 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12599 }
12600 if self.partition_vnode_count != 0 {
12601 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
12602 }
12603 struct_ser.end()
12604 }
12605}
12606impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
12607 #[allow(deprecated)]
12608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12609 where
12610 D: serde::Deserializer<'de>,
12611 {
12612 const FIELDS: &[&str] = &[
12613 "group_id",
12614 "groupId",
12615 "table_ids",
12616 "tableIds",
12617 "partition_vnode_count",
12618 "partitionVnodeCount",
12619 ];
12620
12621 #[allow(clippy::enum_variant_names)]
12622 enum GeneratedField {
12623 GroupId,
12624 TableIds,
12625 PartitionVnodeCount,
12626 }
12627 impl<'de> serde::Deserialize<'de> for GeneratedField {
12628 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12629 where
12630 D: serde::Deserializer<'de>,
12631 {
12632 struct GeneratedVisitor;
12633
12634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12635 type Value = GeneratedField;
12636
12637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12638 write!(formatter, "expected one of: {:?}", &FIELDS)
12639 }
12640
12641 #[allow(unused_variables)]
12642 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12643 where
12644 E: serde::de::Error,
12645 {
12646 match value {
12647 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
12648 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12649 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
12650 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12651 }
12652 }
12653 }
12654 deserializer.deserialize_identifier(GeneratedVisitor)
12655 }
12656 }
12657 struct GeneratedVisitor;
12658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12659 type Value = SplitCompactionGroupRequest;
12660
12661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12662 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
12663 }
12664
12665 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
12666 where
12667 V: serde::de::MapAccess<'de>,
12668 {
12669 let mut group_id__ = None;
12670 let mut table_ids__ = None;
12671 let mut partition_vnode_count__ = None;
12672 while let Some(k) = map_.next_key()? {
12673 match k {
12674 GeneratedField::GroupId => {
12675 if group_id__.is_some() {
12676 return Err(serde::de::Error::duplicate_field("groupId"));
12677 }
12678 group_id__ =
12679 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12680 ;
12681 }
12682 GeneratedField::TableIds => {
12683 if table_ids__.is_some() {
12684 return Err(serde::de::Error::duplicate_field("tableIds"));
12685 }
12686 table_ids__ =
12687 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12688 .into_iter().map(|x| x.0).collect())
12689 ;
12690 }
12691 GeneratedField::PartitionVnodeCount => {
12692 if partition_vnode_count__.is_some() {
12693 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
12694 }
12695 partition_vnode_count__ =
12696 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12697 ;
12698 }
12699 }
12700 }
12701 Ok(SplitCompactionGroupRequest {
12702 group_id: group_id__.unwrap_or_default(),
12703 table_ids: table_ids__.unwrap_or_default(),
12704 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
12705 })
12706 }
12707 }
12708 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
12709 }
12710}
12711impl serde::Serialize for SplitCompactionGroupResponse {
12712 #[allow(deprecated)]
12713 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12714 where
12715 S: serde::Serializer,
12716 {
12717 use serde::ser::SerializeStruct;
12718 let mut len = 0;
12719 if self.new_group_id != 0 {
12720 len += 1;
12721 }
12722 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
12723 if self.new_group_id != 0 {
12724 #[allow(clippy::needless_borrow)]
12725 #[allow(clippy::needless_borrows_for_generic_args)]
12726 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
12727 }
12728 struct_ser.end()
12729 }
12730}
12731impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
12732 #[allow(deprecated)]
12733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12734 where
12735 D: serde::Deserializer<'de>,
12736 {
12737 const FIELDS: &[&str] = &[
12738 "new_group_id",
12739 "newGroupId",
12740 ];
12741
12742 #[allow(clippy::enum_variant_names)]
12743 enum GeneratedField {
12744 NewGroupId,
12745 }
12746 impl<'de> serde::Deserialize<'de> for GeneratedField {
12747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12748 where
12749 D: serde::Deserializer<'de>,
12750 {
12751 struct GeneratedVisitor;
12752
12753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12754 type Value = GeneratedField;
12755
12756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12757 write!(formatter, "expected one of: {:?}", &FIELDS)
12758 }
12759
12760 #[allow(unused_variables)]
12761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12762 where
12763 E: serde::de::Error,
12764 {
12765 match value {
12766 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
12767 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12768 }
12769 }
12770 }
12771 deserializer.deserialize_identifier(GeneratedVisitor)
12772 }
12773 }
12774 struct GeneratedVisitor;
12775 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12776 type Value = SplitCompactionGroupResponse;
12777
12778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12779 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
12780 }
12781
12782 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
12783 where
12784 V: serde::de::MapAccess<'de>,
12785 {
12786 let mut new_group_id__ = None;
12787 while let Some(k) = map_.next_key()? {
12788 match k {
12789 GeneratedField::NewGroupId => {
12790 if new_group_id__.is_some() {
12791 return Err(serde::de::Error::duplicate_field("newGroupId"));
12792 }
12793 new_group_id__ =
12794 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12795 ;
12796 }
12797 }
12798 }
12799 Ok(SplitCompactionGroupResponse {
12800 new_group_id: new_group_id__.unwrap_or_default(),
12801 })
12802 }
12803 }
12804 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
12805 }
12806}
12807impl serde::Serialize for SstableInfo {
12808 #[allow(deprecated)]
12809 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12810 where
12811 S: serde::Serializer,
12812 {
12813 use serde::ser::SerializeStruct;
12814 let mut len = 0;
12815 if self.object_id != 0 {
12816 len += 1;
12817 }
12818 if self.sst_id != 0 {
12819 len += 1;
12820 }
12821 if self.key_range.is_some() {
12822 len += 1;
12823 }
12824 if self.file_size != 0 {
12825 len += 1;
12826 }
12827 if !self.table_ids.is_empty() {
12828 len += 1;
12829 }
12830 if self.meta_offset != 0 {
12831 len += 1;
12832 }
12833 if self.stale_key_count != 0 {
12834 len += 1;
12835 }
12836 if self.total_key_count != 0 {
12837 len += 1;
12838 }
12839 if self.min_epoch != 0 {
12840 len += 1;
12841 }
12842 if self.max_epoch != 0 {
12843 len += 1;
12844 }
12845 if self.uncompressed_file_size != 0 {
12846 len += 1;
12847 }
12848 if self.range_tombstone_count != 0 {
12849 len += 1;
12850 }
12851 if self.bloom_filter_kind != 0 {
12852 len += 1;
12853 }
12854 if self.sst_size != 0 {
12855 len += 1;
12856 }
12857 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
12858 if self.object_id != 0 {
12859 #[allow(clippy::needless_borrow)]
12860 #[allow(clippy::needless_borrows_for_generic_args)]
12861 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
12862 }
12863 if self.sst_id != 0 {
12864 #[allow(clippy::needless_borrow)]
12865 #[allow(clippy::needless_borrows_for_generic_args)]
12866 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
12867 }
12868 if let Some(v) = self.key_range.as_ref() {
12869 struct_ser.serialize_field("keyRange", v)?;
12870 }
12871 if self.file_size != 0 {
12872 #[allow(clippy::needless_borrow)]
12873 #[allow(clippy::needless_borrows_for_generic_args)]
12874 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
12875 }
12876 if !self.table_ids.is_empty() {
12877 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12878 }
12879 if self.meta_offset != 0 {
12880 #[allow(clippy::needless_borrow)]
12881 #[allow(clippy::needless_borrows_for_generic_args)]
12882 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
12883 }
12884 if self.stale_key_count != 0 {
12885 #[allow(clippy::needless_borrow)]
12886 #[allow(clippy::needless_borrows_for_generic_args)]
12887 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
12888 }
12889 if self.total_key_count != 0 {
12890 #[allow(clippy::needless_borrow)]
12891 #[allow(clippy::needless_borrows_for_generic_args)]
12892 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
12893 }
12894 if self.min_epoch != 0 {
12895 #[allow(clippy::needless_borrow)]
12896 #[allow(clippy::needless_borrows_for_generic_args)]
12897 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
12898 }
12899 if self.max_epoch != 0 {
12900 #[allow(clippy::needless_borrow)]
12901 #[allow(clippy::needless_borrows_for_generic_args)]
12902 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
12903 }
12904 if self.uncompressed_file_size != 0 {
12905 #[allow(clippy::needless_borrow)]
12906 #[allow(clippy::needless_borrows_for_generic_args)]
12907 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
12908 }
12909 if self.range_tombstone_count != 0 {
12910 #[allow(clippy::needless_borrow)]
12911 #[allow(clippy::needless_borrows_for_generic_args)]
12912 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
12913 }
12914 if self.bloom_filter_kind != 0 {
12915 let v = BloomFilterType::try_from(self.bloom_filter_kind)
12916 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
12917 struct_ser.serialize_field("bloomFilterKind", &v)?;
12918 }
12919 if self.sst_size != 0 {
12920 #[allow(clippy::needless_borrow)]
12921 #[allow(clippy::needless_borrows_for_generic_args)]
12922 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
12923 }
12924 struct_ser.end()
12925 }
12926}
12927impl<'de> serde::Deserialize<'de> for SstableInfo {
12928 #[allow(deprecated)]
12929 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12930 where
12931 D: serde::Deserializer<'de>,
12932 {
12933 const FIELDS: &[&str] = &[
12934 "object_id",
12935 "objectId",
12936 "sst_id",
12937 "sstId",
12938 "key_range",
12939 "keyRange",
12940 "file_size",
12941 "fileSize",
12942 "table_ids",
12943 "tableIds",
12944 "meta_offset",
12945 "metaOffset",
12946 "stale_key_count",
12947 "staleKeyCount",
12948 "total_key_count",
12949 "totalKeyCount",
12950 "min_epoch",
12951 "minEpoch",
12952 "max_epoch",
12953 "maxEpoch",
12954 "uncompressed_file_size",
12955 "uncompressedFileSize",
12956 "range_tombstone_count",
12957 "rangeTombstoneCount",
12958 "bloom_filter_kind",
12959 "bloomFilterKind",
12960 "sst_size",
12961 "sstSize",
12962 ];
12963
12964 #[allow(clippy::enum_variant_names)]
12965 enum GeneratedField {
12966 ObjectId,
12967 SstId,
12968 KeyRange,
12969 FileSize,
12970 TableIds,
12971 MetaOffset,
12972 StaleKeyCount,
12973 TotalKeyCount,
12974 MinEpoch,
12975 MaxEpoch,
12976 UncompressedFileSize,
12977 RangeTombstoneCount,
12978 BloomFilterKind,
12979 SstSize,
12980 }
12981 impl<'de> serde::Deserialize<'de> for GeneratedField {
12982 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12983 where
12984 D: serde::Deserializer<'de>,
12985 {
12986 struct GeneratedVisitor;
12987
12988 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12989 type Value = GeneratedField;
12990
12991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12992 write!(formatter, "expected one of: {:?}", &FIELDS)
12993 }
12994
12995 #[allow(unused_variables)]
12996 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12997 where
12998 E: serde::de::Error,
12999 {
13000 match value {
13001 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
13002 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
13003 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
13004 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
13005 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13006 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
13007 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
13008 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
13009 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
13010 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
13011 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
13012 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
13013 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
13014 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
13015 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13016 }
13017 }
13018 }
13019 deserializer.deserialize_identifier(GeneratedVisitor)
13020 }
13021 }
13022 struct GeneratedVisitor;
13023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13024 type Value = SstableInfo;
13025
13026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13027 formatter.write_str("struct hummock.SstableInfo")
13028 }
13029
13030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
13031 where
13032 V: serde::de::MapAccess<'de>,
13033 {
13034 let mut object_id__ = None;
13035 let mut sst_id__ = None;
13036 let mut key_range__ = None;
13037 let mut file_size__ = None;
13038 let mut table_ids__ = None;
13039 let mut meta_offset__ = None;
13040 let mut stale_key_count__ = None;
13041 let mut total_key_count__ = None;
13042 let mut min_epoch__ = None;
13043 let mut max_epoch__ = None;
13044 let mut uncompressed_file_size__ = None;
13045 let mut range_tombstone_count__ = None;
13046 let mut bloom_filter_kind__ = None;
13047 let mut sst_size__ = None;
13048 while let Some(k) = map_.next_key()? {
13049 match k {
13050 GeneratedField::ObjectId => {
13051 if object_id__.is_some() {
13052 return Err(serde::de::Error::duplicate_field("objectId"));
13053 }
13054 object_id__ =
13055 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13056 ;
13057 }
13058 GeneratedField::SstId => {
13059 if sst_id__.is_some() {
13060 return Err(serde::de::Error::duplicate_field("sstId"));
13061 }
13062 sst_id__ =
13063 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13064 ;
13065 }
13066 GeneratedField::KeyRange => {
13067 if key_range__.is_some() {
13068 return Err(serde::de::Error::duplicate_field("keyRange"));
13069 }
13070 key_range__ = map_.next_value()?;
13071 }
13072 GeneratedField::FileSize => {
13073 if file_size__.is_some() {
13074 return Err(serde::de::Error::duplicate_field("fileSize"));
13075 }
13076 file_size__ =
13077 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13078 ;
13079 }
13080 GeneratedField::TableIds => {
13081 if table_ids__.is_some() {
13082 return Err(serde::de::Error::duplicate_field("tableIds"));
13083 }
13084 table_ids__ =
13085 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13086 .into_iter().map(|x| x.0).collect())
13087 ;
13088 }
13089 GeneratedField::MetaOffset => {
13090 if meta_offset__.is_some() {
13091 return Err(serde::de::Error::duplicate_field("metaOffset"));
13092 }
13093 meta_offset__ =
13094 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13095 ;
13096 }
13097 GeneratedField::StaleKeyCount => {
13098 if stale_key_count__.is_some() {
13099 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
13100 }
13101 stale_key_count__ =
13102 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13103 ;
13104 }
13105 GeneratedField::TotalKeyCount => {
13106 if total_key_count__.is_some() {
13107 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
13108 }
13109 total_key_count__ =
13110 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13111 ;
13112 }
13113 GeneratedField::MinEpoch => {
13114 if min_epoch__.is_some() {
13115 return Err(serde::de::Error::duplicate_field("minEpoch"));
13116 }
13117 min_epoch__ =
13118 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13119 ;
13120 }
13121 GeneratedField::MaxEpoch => {
13122 if max_epoch__.is_some() {
13123 return Err(serde::de::Error::duplicate_field("maxEpoch"));
13124 }
13125 max_epoch__ =
13126 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13127 ;
13128 }
13129 GeneratedField::UncompressedFileSize => {
13130 if uncompressed_file_size__.is_some() {
13131 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
13132 }
13133 uncompressed_file_size__ =
13134 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13135 ;
13136 }
13137 GeneratedField::RangeTombstoneCount => {
13138 if range_tombstone_count__.is_some() {
13139 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
13140 }
13141 range_tombstone_count__ =
13142 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13143 ;
13144 }
13145 GeneratedField::BloomFilterKind => {
13146 if bloom_filter_kind__.is_some() {
13147 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
13148 }
13149 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
13150 }
13151 GeneratedField::SstSize => {
13152 if sst_size__.is_some() {
13153 return Err(serde::de::Error::duplicate_field("sstSize"));
13154 }
13155 sst_size__ =
13156 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13157 ;
13158 }
13159 }
13160 }
13161 Ok(SstableInfo {
13162 object_id: object_id__.unwrap_or_default(),
13163 sst_id: sst_id__.unwrap_or_default(),
13164 key_range: key_range__,
13165 file_size: file_size__.unwrap_or_default(),
13166 table_ids: table_ids__.unwrap_or_default(),
13167 meta_offset: meta_offset__.unwrap_or_default(),
13168 stale_key_count: stale_key_count__.unwrap_or_default(),
13169 total_key_count: total_key_count__.unwrap_or_default(),
13170 min_epoch: min_epoch__.unwrap_or_default(),
13171 max_epoch: max_epoch__.unwrap_or_default(),
13172 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
13173 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
13174 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
13175 sst_size: sst_size__.unwrap_or_default(),
13176 })
13177 }
13178 }
13179 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
13180 }
13181}
13182impl serde::Serialize for StateTableInfo {
13183 #[allow(deprecated)]
13184 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13185 where
13186 S: serde::Serializer,
13187 {
13188 use serde::ser::SerializeStruct;
13189 let mut len = 0;
13190 if self.committed_epoch != 0 {
13191 len += 1;
13192 }
13193 if self.compaction_group_id != 0 {
13194 len += 1;
13195 }
13196 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
13197 if self.committed_epoch != 0 {
13198 #[allow(clippy::needless_borrow)]
13199 #[allow(clippy::needless_borrows_for_generic_args)]
13200 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13201 }
13202 if self.compaction_group_id != 0 {
13203 #[allow(clippy::needless_borrow)]
13204 #[allow(clippy::needless_borrows_for_generic_args)]
13205 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13206 }
13207 struct_ser.end()
13208 }
13209}
13210impl<'de> serde::Deserialize<'de> for StateTableInfo {
13211 #[allow(deprecated)]
13212 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13213 where
13214 D: serde::Deserializer<'de>,
13215 {
13216 const FIELDS: &[&str] = &[
13217 "committed_epoch",
13218 "committedEpoch",
13219 "compaction_group_id",
13220 "compactionGroupId",
13221 ];
13222
13223 #[allow(clippy::enum_variant_names)]
13224 enum GeneratedField {
13225 CommittedEpoch,
13226 CompactionGroupId,
13227 }
13228 impl<'de> serde::Deserialize<'de> for GeneratedField {
13229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13230 where
13231 D: serde::Deserializer<'de>,
13232 {
13233 struct GeneratedVisitor;
13234
13235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13236 type Value = GeneratedField;
13237
13238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13239 write!(formatter, "expected one of: {:?}", &FIELDS)
13240 }
13241
13242 #[allow(unused_variables)]
13243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13244 where
13245 E: serde::de::Error,
13246 {
13247 match value {
13248 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13249 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13250 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13251 }
13252 }
13253 }
13254 deserializer.deserialize_identifier(GeneratedVisitor)
13255 }
13256 }
13257 struct GeneratedVisitor;
13258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13259 type Value = StateTableInfo;
13260
13261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13262 formatter.write_str("struct hummock.StateTableInfo")
13263 }
13264
13265 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
13266 where
13267 V: serde::de::MapAccess<'de>,
13268 {
13269 let mut committed_epoch__ = None;
13270 let mut compaction_group_id__ = None;
13271 while let Some(k) = map_.next_key()? {
13272 match k {
13273 GeneratedField::CommittedEpoch => {
13274 if committed_epoch__.is_some() {
13275 return Err(serde::de::Error::duplicate_field("committedEpoch"));
13276 }
13277 committed_epoch__ =
13278 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13279 ;
13280 }
13281 GeneratedField::CompactionGroupId => {
13282 if compaction_group_id__.is_some() {
13283 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
13284 }
13285 compaction_group_id__ =
13286 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13287 ;
13288 }
13289 }
13290 }
13291 Ok(StateTableInfo {
13292 committed_epoch: committed_epoch__.unwrap_or_default(),
13293 compaction_group_id: compaction_group_id__.unwrap_or_default(),
13294 })
13295 }
13296 }
13297 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
13298 }
13299}
13300impl serde::Serialize for StateTableInfoDelta {
13301 #[allow(deprecated)]
13302 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13303 where
13304 S: serde::Serializer,
13305 {
13306 use serde::ser::SerializeStruct;
13307 let mut len = 0;
13308 if self.committed_epoch != 0 {
13309 len += 1;
13310 }
13311 if self.compaction_group_id != 0 {
13312 len += 1;
13313 }
13314 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
13315 if self.committed_epoch != 0 {
13316 #[allow(clippy::needless_borrow)]
13317 #[allow(clippy::needless_borrows_for_generic_args)]
13318 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13319 }
13320 if self.compaction_group_id != 0 {
13321 #[allow(clippy::needless_borrow)]
13322 #[allow(clippy::needless_borrows_for_generic_args)]
13323 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13324 }
13325 struct_ser.end()
13326 }
13327}
13328impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
13329 #[allow(deprecated)]
13330 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13331 where
13332 D: serde::Deserializer<'de>,
13333 {
13334 const FIELDS: &[&str] = &[
13335 "committed_epoch",
13336 "committedEpoch",
13337 "compaction_group_id",
13338 "compactionGroupId",
13339 ];
13340
13341 #[allow(clippy::enum_variant_names)]
13342 enum GeneratedField {
13343 CommittedEpoch,
13344 CompactionGroupId,
13345 }
13346 impl<'de> serde::Deserialize<'de> for GeneratedField {
13347 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13348 where
13349 D: serde::Deserializer<'de>,
13350 {
13351 struct GeneratedVisitor;
13352
13353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13354 type Value = GeneratedField;
13355
13356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13357 write!(formatter, "expected one of: {:?}", &FIELDS)
13358 }
13359
13360 #[allow(unused_variables)]
13361 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13362 where
13363 E: serde::de::Error,
13364 {
13365 match value {
13366 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13367 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13368 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13369 }
13370 }
13371 }
13372 deserializer.deserialize_identifier(GeneratedVisitor)
13373 }
13374 }
13375 struct GeneratedVisitor;
13376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13377 type Value = StateTableInfoDelta;
13378
13379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13380 formatter.write_str("struct hummock.StateTableInfoDelta")
13381 }
13382
13383 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
13384 where
13385 V: serde::de::MapAccess<'de>,
13386 {
13387 let mut committed_epoch__ = None;
13388 let mut compaction_group_id__ = None;
13389 while let Some(k) = map_.next_key()? {
13390 match k {
13391 GeneratedField::CommittedEpoch => {
13392 if committed_epoch__.is_some() {
13393 return Err(serde::de::Error::duplicate_field("committedEpoch"));
13394 }
13395 committed_epoch__ =
13396 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13397 ;
13398 }
13399 GeneratedField::CompactionGroupId => {
13400 if compaction_group_id__.is_some() {
13401 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
13402 }
13403 compaction_group_id__ =
13404 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13405 ;
13406 }
13407 }
13408 }
13409 Ok(StateTableInfoDelta {
13410 committed_epoch: committed_epoch__.unwrap_or_default(),
13411 compaction_group_id: compaction_group_id__.unwrap_or_default(),
13412 })
13413 }
13414 }
13415 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
13416 }
13417}
13418impl serde::Serialize for SubscribeCompactionEventRequest {
13419 #[allow(deprecated)]
13420 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13421 where
13422 S: serde::Serializer,
13423 {
13424 use serde::ser::SerializeStruct;
13425 let mut len = 0;
13426 if self.create_at != 0 {
13427 len += 1;
13428 }
13429 if self.event.is_some() {
13430 len += 1;
13431 }
13432 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
13433 if self.create_at != 0 {
13434 #[allow(clippy::needless_borrow)]
13435 #[allow(clippy::needless_borrows_for_generic_args)]
13436 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
13437 }
13438 if let Some(v) = self.event.as_ref() {
13439 match v {
13440 subscribe_compaction_event_request::Event::Register(v) => {
13441 struct_ser.serialize_field("register", v)?;
13442 }
13443 subscribe_compaction_event_request::Event::PullTask(v) => {
13444 struct_ser.serialize_field("pullTask", v)?;
13445 }
13446 subscribe_compaction_event_request::Event::ReportTask(v) => {
13447 struct_ser.serialize_field("reportTask", v)?;
13448 }
13449 subscribe_compaction_event_request::Event::HeartBeat(v) => {
13450 struct_ser.serialize_field("heartBeat", v)?;
13451 }
13452 }
13453 }
13454 struct_ser.end()
13455 }
13456}
13457impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
13458 #[allow(deprecated)]
13459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13460 where
13461 D: serde::Deserializer<'de>,
13462 {
13463 const FIELDS: &[&str] = &[
13464 "create_at",
13465 "createAt",
13466 "register",
13467 "pull_task",
13468 "pullTask",
13469 "report_task",
13470 "reportTask",
13471 "heart_beat",
13472 "heartBeat",
13473 ];
13474
13475 #[allow(clippy::enum_variant_names)]
13476 enum GeneratedField {
13477 CreateAt,
13478 Register,
13479 PullTask,
13480 ReportTask,
13481 HeartBeat,
13482 }
13483 impl<'de> serde::Deserialize<'de> for GeneratedField {
13484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13485 where
13486 D: serde::Deserializer<'de>,
13487 {
13488 struct GeneratedVisitor;
13489
13490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13491 type Value = GeneratedField;
13492
13493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13494 write!(formatter, "expected one of: {:?}", &FIELDS)
13495 }
13496
13497 #[allow(unused_variables)]
13498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13499 where
13500 E: serde::de::Error,
13501 {
13502 match value {
13503 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
13504 "register" => Ok(GeneratedField::Register),
13505 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
13506 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
13507 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
13508 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13509 }
13510 }
13511 }
13512 deserializer.deserialize_identifier(GeneratedVisitor)
13513 }
13514 }
13515 struct GeneratedVisitor;
13516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13517 type Value = SubscribeCompactionEventRequest;
13518
13519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13520 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
13521 }
13522
13523 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
13524 where
13525 V: serde::de::MapAccess<'de>,
13526 {
13527 let mut create_at__ = None;
13528 let mut event__ = None;
13529 while let Some(k) = map_.next_key()? {
13530 match k {
13531 GeneratedField::CreateAt => {
13532 if create_at__.is_some() {
13533 return Err(serde::de::Error::duplicate_field("createAt"));
13534 }
13535 create_at__ =
13536 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13537 ;
13538 }
13539 GeneratedField::Register => {
13540 if event__.is_some() {
13541 return Err(serde::de::Error::duplicate_field("register"));
13542 }
13543 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
13544;
13545 }
13546 GeneratedField::PullTask => {
13547 if event__.is_some() {
13548 return Err(serde::de::Error::duplicate_field("pullTask"));
13549 }
13550 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
13551;
13552 }
13553 GeneratedField::ReportTask => {
13554 if event__.is_some() {
13555 return Err(serde::de::Error::duplicate_field("reportTask"));
13556 }
13557 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
13558;
13559 }
13560 GeneratedField::HeartBeat => {
13561 if event__.is_some() {
13562 return Err(serde::de::Error::duplicate_field("heartBeat"));
13563 }
13564 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
13565;
13566 }
13567 }
13568 }
13569 Ok(SubscribeCompactionEventRequest {
13570 create_at: create_at__.unwrap_or_default(),
13571 event: event__,
13572 })
13573 }
13574 }
13575 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
13576 }
13577}
13578impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
13579 #[allow(deprecated)]
13580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13581 where
13582 S: serde::Serializer,
13583 {
13584 use serde::ser::SerializeStruct;
13585 let mut len = 0;
13586 if !self.progress.is_empty() {
13587 len += 1;
13588 }
13589 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
13590 if !self.progress.is_empty() {
13591 struct_ser.serialize_field("progress", &self.progress)?;
13592 }
13593 struct_ser.end()
13594 }
13595}
13596impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
13597 #[allow(deprecated)]
13598 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13599 where
13600 D: serde::Deserializer<'de>,
13601 {
13602 const FIELDS: &[&str] = &[
13603 "progress",
13604 ];
13605
13606 #[allow(clippy::enum_variant_names)]
13607 enum GeneratedField {
13608 Progress,
13609 }
13610 impl<'de> serde::Deserialize<'de> for GeneratedField {
13611 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13612 where
13613 D: serde::Deserializer<'de>,
13614 {
13615 struct GeneratedVisitor;
13616
13617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13618 type Value = GeneratedField;
13619
13620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13621 write!(formatter, "expected one of: {:?}", &FIELDS)
13622 }
13623
13624 #[allow(unused_variables)]
13625 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13626 where
13627 E: serde::de::Error,
13628 {
13629 match value {
13630 "progress" => Ok(GeneratedField::Progress),
13631 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13632 }
13633 }
13634 }
13635 deserializer.deserialize_identifier(GeneratedVisitor)
13636 }
13637 }
13638 struct GeneratedVisitor;
13639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13640 type Value = subscribe_compaction_event_request::HeartBeat;
13641
13642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13643 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
13644 }
13645
13646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
13647 where
13648 V: serde::de::MapAccess<'de>,
13649 {
13650 let mut progress__ = None;
13651 while let Some(k) = map_.next_key()? {
13652 match k {
13653 GeneratedField::Progress => {
13654 if progress__.is_some() {
13655 return Err(serde::de::Error::duplicate_field("progress"));
13656 }
13657 progress__ = Some(map_.next_value()?);
13658 }
13659 }
13660 }
13661 Ok(subscribe_compaction_event_request::HeartBeat {
13662 progress: progress__.unwrap_or_default(),
13663 })
13664 }
13665 }
13666 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
13667 }
13668}
13669impl serde::Serialize for subscribe_compaction_event_request::PullTask {
13670 #[allow(deprecated)]
13671 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13672 where
13673 S: serde::Serializer,
13674 {
13675 use serde::ser::SerializeStruct;
13676 let mut len = 0;
13677 if self.pull_task_count != 0 {
13678 len += 1;
13679 }
13680 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
13681 if self.pull_task_count != 0 {
13682 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
13683 }
13684 struct_ser.end()
13685 }
13686}
13687impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
13688 #[allow(deprecated)]
13689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13690 where
13691 D: serde::Deserializer<'de>,
13692 {
13693 const FIELDS: &[&str] = &[
13694 "pull_task_count",
13695 "pullTaskCount",
13696 ];
13697
13698 #[allow(clippy::enum_variant_names)]
13699 enum GeneratedField {
13700 PullTaskCount,
13701 }
13702 impl<'de> serde::Deserialize<'de> for GeneratedField {
13703 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13704 where
13705 D: serde::Deserializer<'de>,
13706 {
13707 struct GeneratedVisitor;
13708
13709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13710 type Value = GeneratedField;
13711
13712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13713 write!(formatter, "expected one of: {:?}", &FIELDS)
13714 }
13715
13716 #[allow(unused_variables)]
13717 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13718 where
13719 E: serde::de::Error,
13720 {
13721 match value {
13722 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
13723 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13724 }
13725 }
13726 }
13727 deserializer.deserialize_identifier(GeneratedVisitor)
13728 }
13729 }
13730 struct GeneratedVisitor;
13731 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13732 type Value = subscribe_compaction_event_request::PullTask;
13733
13734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13735 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
13736 }
13737
13738 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
13739 where
13740 V: serde::de::MapAccess<'de>,
13741 {
13742 let mut pull_task_count__ = None;
13743 while let Some(k) = map_.next_key()? {
13744 match k {
13745 GeneratedField::PullTaskCount => {
13746 if pull_task_count__.is_some() {
13747 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
13748 }
13749 pull_task_count__ =
13750 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13751 ;
13752 }
13753 }
13754 }
13755 Ok(subscribe_compaction_event_request::PullTask {
13756 pull_task_count: pull_task_count__.unwrap_or_default(),
13757 })
13758 }
13759 }
13760 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
13761 }
13762}
13763impl serde::Serialize for subscribe_compaction_event_request::Register {
13764 #[allow(deprecated)]
13765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13766 where
13767 S: serde::Serializer,
13768 {
13769 use serde::ser::SerializeStruct;
13770 let mut len = 0;
13771 if self.context_id != 0 {
13772 len += 1;
13773 }
13774 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
13775 if self.context_id != 0 {
13776 struct_ser.serialize_field("contextId", &self.context_id)?;
13777 }
13778 struct_ser.end()
13779 }
13780}
13781impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
13782 #[allow(deprecated)]
13783 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13784 where
13785 D: serde::Deserializer<'de>,
13786 {
13787 const FIELDS: &[&str] = &[
13788 "context_id",
13789 "contextId",
13790 ];
13791
13792 #[allow(clippy::enum_variant_names)]
13793 enum GeneratedField {
13794 ContextId,
13795 }
13796 impl<'de> serde::Deserialize<'de> for GeneratedField {
13797 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13798 where
13799 D: serde::Deserializer<'de>,
13800 {
13801 struct GeneratedVisitor;
13802
13803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13804 type Value = GeneratedField;
13805
13806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13807 write!(formatter, "expected one of: {:?}", &FIELDS)
13808 }
13809
13810 #[allow(unused_variables)]
13811 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13812 where
13813 E: serde::de::Error,
13814 {
13815 match value {
13816 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
13817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13818 }
13819 }
13820 }
13821 deserializer.deserialize_identifier(GeneratedVisitor)
13822 }
13823 }
13824 struct GeneratedVisitor;
13825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13826 type Value = subscribe_compaction_event_request::Register;
13827
13828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13829 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
13830 }
13831
13832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
13833 where
13834 V: serde::de::MapAccess<'de>,
13835 {
13836 let mut context_id__ = None;
13837 while let Some(k) = map_.next_key()? {
13838 match k {
13839 GeneratedField::ContextId => {
13840 if context_id__.is_some() {
13841 return Err(serde::de::Error::duplicate_field("contextId"));
13842 }
13843 context_id__ =
13844 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13845 ;
13846 }
13847 }
13848 }
13849 Ok(subscribe_compaction_event_request::Register {
13850 context_id: context_id__.unwrap_or_default(),
13851 })
13852 }
13853 }
13854 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
13855 }
13856}
13857impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
13858 #[allow(deprecated)]
13859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13860 where
13861 S: serde::Serializer,
13862 {
13863 use serde::ser::SerializeStruct;
13864 let mut len = 0;
13865 if !self.table_stats_change.is_empty() {
13866 len += 1;
13867 }
13868 if self.task_id != 0 {
13869 len += 1;
13870 }
13871 if self.task_status != 0 {
13872 len += 1;
13873 }
13874 if !self.sorted_output_ssts.is_empty() {
13875 len += 1;
13876 }
13877 if !self.object_timestamps.is_empty() {
13878 len += 1;
13879 }
13880 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
13881 if !self.table_stats_change.is_empty() {
13882 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
13883 }
13884 if self.task_id != 0 {
13885 #[allow(clippy::needless_borrow)]
13886 #[allow(clippy::needless_borrows_for_generic_args)]
13887 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
13888 }
13889 if self.task_status != 0 {
13890 let v = compact_task::TaskStatus::try_from(self.task_status)
13891 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
13892 struct_ser.serialize_field("taskStatus", &v)?;
13893 }
13894 if !self.sorted_output_ssts.is_empty() {
13895 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
13896 }
13897 if !self.object_timestamps.is_empty() {
13898 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
13899 .map(|(k, v)| (k, v.to_string())).collect();
13900 struct_ser.serialize_field("objectTimestamps", &v)?;
13901 }
13902 struct_ser.end()
13903 }
13904}
13905impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
13906 #[allow(deprecated)]
13907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13908 where
13909 D: serde::Deserializer<'de>,
13910 {
13911 const FIELDS: &[&str] = &[
13912 "table_stats_change",
13913 "tableStatsChange",
13914 "task_id",
13915 "taskId",
13916 "task_status",
13917 "taskStatus",
13918 "sorted_output_ssts",
13919 "sortedOutputSsts",
13920 "object_timestamps",
13921 "objectTimestamps",
13922 ];
13923
13924 #[allow(clippy::enum_variant_names)]
13925 enum GeneratedField {
13926 TableStatsChange,
13927 TaskId,
13928 TaskStatus,
13929 SortedOutputSsts,
13930 ObjectTimestamps,
13931 }
13932 impl<'de> serde::Deserialize<'de> for GeneratedField {
13933 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13934 where
13935 D: serde::Deserializer<'de>,
13936 {
13937 struct GeneratedVisitor;
13938
13939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13940 type Value = GeneratedField;
13941
13942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13943 write!(formatter, "expected one of: {:?}", &FIELDS)
13944 }
13945
13946 #[allow(unused_variables)]
13947 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13948 where
13949 E: serde::de::Error,
13950 {
13951 match value {
13952 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
13953 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
13954 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
13955 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
13956 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
13957 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13958 }
13959 }
13960 }
13961 deserializer.deserialize_identifier(GeneratedVisitor)
13962 }
13963 }
13964 struct GeneratedVisitor;
13965 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13966 type Value = subscribe_compaction_event_request::ReportTask;
13967
13968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13969 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
13970 }
13971
13972 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
13973 where
13974 V: serde::de::MapAccess<'de>,
13975 {
13976 let mut table_stats_change__ = None;
13977 let mut task_id__ = None;
13978 let mut task_status__ = None;
13979 let mut sorted_output_ssts__ = None;
13980 let mut object_timestamps__ = None;
13981 while let Some(k) = map_.next_key()? {
13982 match k {
13983 GeneratedField::TableStatsChange => {
13984 if table_stats_change__.is_some() {
13985 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
13986 }
13987 table_stats_change__ = Some(
13988 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13989 .into_iter().map(|(k,v)| (k.0, v)).collect()
13990 );
13991 }
13992 GeneratedField::TaskId => {
13993 if task_id__.is_some() {
13994 return Err(serde::de::Error::duplicate_field("taskId"));
13995 }
13996 task_id__ =
13997 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13998 ;
13999 }
14000 GeneratedField::TaskStatus => {
14001 if task_status__.is_some() {
14002 return Err(serde::de::Error::duplicate_field("taskStatus"));
14003 }
14004 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
14005 }
14006 GeneratedField::SortedOutputSsts => {
14007 if sorted_output_ssts__.is_some() {
14008 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
14009 }
14010 sorted_output_ssts__ = Some(map_.next_value()?);
14011 }
14012 GeneratedField::ObjectTimestamps => {
14013 if object_timestamps__.is_some() {
14014 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
14015 }
14016 object_timestamps__ = Some(
14017 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14018 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
14019 );
14020 }
14021 }
14022 }
14023 Ok(subscribe_compaction_event_request::ReportTask {
14024 table_stats_change: table_stats_change__.unwrap_or_default(),
14025 task_id: task_id__.unwrap_or_default(),
14026 task_status: task_status__.unwrap_or_default(),
14027 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
14028 object_timestamps: object_timestamps__.unwrap_or_default(),
14029 })
14030 }
14031 }
14032 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
14033 }
14034}
14035impl serde::Serialize for SubscribeCompactionEventResponse {
14036 #[allow(deprecated)]
14037 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14038 where
14039 S: serde::Serializer,
14040 {
14041 use serde::ser::SerializeStruct;
14042 let mut len = 0;
14043 if self.create_at != 0 {
14044 len += 1;
14045 }
14046 if self.event.is_some() {
14047 len += 1;
14048 }
14049 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
14050 if self.create_at != 0 {
14051 #[allow(clippy::needless_borrow)]
14052 #[allow(clippy::needless_borrows_for_generic_args)]
14053 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14054 }
14055 if let Some(v) = self.event.as_ref() {
14056 match v {
14057 subscribe_compaction_event_response::Event::CompactTask(v) => {
14058 struct_ser.serialize_field("compactTask", v)?;
14059 }
14060 subscribe_compaction_event_response::Event::VacuumTask(v) => {
14061 struct_ser.serialize_field("vacuumTask", v)?;
14062 }
14063 subscribe_compaction_event_response::Event::FullScanTask(v) => {
14064 struct_ser.serialize_field("fullScanTask", v)?;
14065 }
14066 subscribe_compaction_event_response::Event::ValidationTask(v) => {
14067 struct_ser.serialize_field("validationTask", v)?;
14068 }
14069 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
14070 struct_ser.serialize_field("cancelCompactTask", v)?;
14071 }
14072 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
14073 struct_ser.serialize_field("pullTaskAck", v)?;
14074 }
14075 }
14076 }
14077 struct_ser.end()
14078 }
14079}
14080impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
14081 #[allow(deprecated)]
14082 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14083 where
14084 D: serde::Deserializer<'de>,
14085 {
14086 const FIELDS: &[&str] = &[
14087 "create_at",
14088 "createAt",
14089 "compact_task",
14090 "compactTask",
14091 "vacuum_task",
14092 "vacuumTask",
14093 "full_scan_task",
14094 "fullScanTask",
14095 "validation_task",
14096 "validationTask",
14097 "cancel_compact_task",
14098 "cancelCompactTask",
14099 "pull_task_ack",
14100 "pullTaskAck",
14101 ];
14102
14103 #[allow(clippy::enum_variant_names)]
14104 enum GeneratedField {
14105 CreateAt,
14106 CompactTask,
14107 VacuumTask,
14108 FullScanTask,
14109 ValidationTask,
14110 CancelCompactTask,
14111 PullTaskAck,
14112 }
14113 impl<'de> serde::Deserialize<'de> for GeneratedField {
14114 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14115 where
14116 D: serde::Deserializer<'de>,
14117 {
14118 struct GeneratedVisitor;
14119
14120 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14121 type Value = GeneratedField;
14122
14123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14124 write!(formatter, "expected one of: {:?}", &FIELDS)
14125 }
14126
14127 #[allow(unused_variables)]
14128 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14129 where
14130 E: serde::de::Error,
14131 {
14132 match value {
14133 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14134 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
14135 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
14136 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
14137 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
14138 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
14139 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
14140 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14141 }
14142 }
14143 }
14144 deserializer.deserialize_identifier(GeneratedVisitor)
14145 }
14146 }
14147 struct GeneratedVisitor;
14148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14149 type Value = SubscribeCompactionEventResponse;
14150
14151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14152 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
14153 }
14154
14155 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
14156 where
14157 V: serde::de::MapAccess<'de>,
14158 {
14159 let mut create_at__ = None;
14160 let mut event__ = None;
14161 while let Some(k) = map_.next_key()? {
14162 match k {
14163 GeneratedField::CreateAt => {
14164 if create_at__.is_some() {
14165 return Err(serde::de::Error::duplicate_field("createAt"));
14166 }
14167 create_at__ =
14168 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14169 ;
14170 }
14171 GeneratedField::CompactTask => {
14172 if event__.is_some() {
14173 return Err(serde::de::Error::duplicate_field("compactTask"));
14174 }
14175 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
14176;
14177 }
14178 GeneratedField::VacuumTask => {
14179 if event__.is_some() {
14180 return Err(serde::de::Error::duplicate_field("vacuumTask"));
14181 }
14182 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
14183;
14184 }
14185 GeneratedField::FullScanTask => {
14186 if event__.is_some() {
14187 return Err(serde::de::Error::duplicate_field("fullScanTask"));
14188 }
14189 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
14190;
14191 }
14192 GeneratedField::ValidationTask => {
14193 if event__.is_some() {
14194 return Err(serde::de::Error::duplicate_field("validationTask"));
14195 }
14196 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
14197;
14198 }
14199 GeneratedField::CancelCompactTask => {
14200 if event__.is_some() {
14201 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
14202 }
14203 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
14204;
14205 }
14206 GeneratedField::PullTaskAck => {
14207 if event__.is_some() {
14208 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
14209 }
14210 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
14211;
14212 }
14213 }
14214 }
14215 Ok(SubscribeCompactionEventResponse {
14216 create_at: create_at__.unwrap_or_default(),
14217 event: event__,
14218 })
14219 }
14220 }
14221 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
14222 }
14223}
14224impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
14225 #[allow(deprecated)]
14226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14227 where
14228 S: serde::Serializer,
14229 {
14230 use serde::ser::SerializeStruct;
14231 let len = 0;
14232 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
14233 struct_ser.end()
14234 }
14235}
14236impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
14237 #[allow(deprecated)]
14238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14239 where
14240 D: serde::Deserializer<'de>,
14241 {
14242 const FIELDS: &[&str] = &[
14243 ];
14244
14245 #[allow(clippy::enum_variant_names)]
14246 enum GeneratedField {
14247 }
14248 impl<'de> serde::Deserialize<'de> for GeneratedField {
14249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14250 where
14251 D: serde::Deserializer<'de>,
14252 {
14253 struct GeneratedVisitor;
14254
14255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14256 type Value = GeneratedField;
14257
14258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14259 write!(formatter, "expected one of: {:?}", &FIELDS)
14260 }
14261
14262 #[allow(unused_variables)]
14263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14264 where
14265 E: serde::de::Error,
14266 {
14267 Err(serde::de::Error::unknown_field(value, FIELDS))
14268 }
14269 }
14270 deserializer.deserialize_identifier(GeneratedVisitor)
14271 }
14272 }
14273 struct GeneratedVisitor;
14274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14275 type Value = subscribe_compaction_event_response::PullTaskAck;
14276
14277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14278 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
14279 }
14280
14281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
14282 where
14283 V: serde::de::MapAccess<'de>,
14284 {
14285 while map_.next_key::<GeneratedField>()?.is_some() {
14286 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14287 }
14288 Ok(subscribe_compaction_event_response::PullTaskAck {
14289 })
14290 }
14291 }
14292 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
14293 }
14294}
14295impl serde::Serialize for TableChangeLog {
14296 #[allow(deprecated)]
14297 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14298 where
14299 S: serde::Serializer,
14300 {
14301 use serde::ser::SerializeStruct;
14302 let mut len = 0;
14303 if !self.change_logs.is_empty() {
14304 len += 1;
14305 }
14306 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
14307 if !self.change_logs.is_empty() {
14308 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
14309 }
14310 struct_ser.end()
14311 }
14312}
14313impl<'de> serde::Deserialize<'de> for TableChangeLog {
14314 #[allow(deprecated)]
14315 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14316 where
14317 D: serde::Deserializer<'de>,
14318 {
14319 const FIELDS: &[&str] = &[
14320 "change_logs",
14321 "changeLogs",
14322 ];
14323
14324 #[allow(clippy::enum_variant_names)]
14325 enum GeneratedField {
14326 ChangeLogs,
14327 }
14328 impl<'de> serde::Deserialize<'de> for GeneratedField {
14329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14330 where
14331 D: serde::Deserializer<'de>,
14332 {
14333 struct GeneratedVisitor;
14334
14335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14336 type Value = GeneratedField;
14337
14338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14339 write!(formatter, "expected one of: {:?}", &FIELDS)
14340 }
14341
14342 #[allow(unused_variables)]
14343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14344 where
14345 E: serde::de::Error,
14346 {
14347 match value {
14348 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
14349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14350 }
14351 }
14352 }
14353 deserializer.deserialize_identifier(GeneratedVisitor)
14354 }
14355 }
14356 struct GeneratedVisitor;
14357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14358 type Value = TableChangeLog;
14359
14360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14361 formatter.write_str("struct hummock.TableChangeLog")
14362 }
14363
14364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
14365 where
14366 V: serde::de::MapAccess<'de>,
14367 {
14368 let mut change_logs__ = None;
14369 while let Some(k) = map_.next_key()? {
14370 match k {
14371 GeneratedField::ChangeLogs => {
14372 if change_logs__.is_some() {
14373 return Err(serde::de::Error::duplicate_field("changeLogs"));
14374 }
14375 change_logs__ = Some(map_.next_value()?);
14376 }
14377 }
14378 }
14379 Ok(TableChangeLog {
14380 change_logs: change_logs__.unwrap_or_default(),
14381 })
14382 }
14383 }
14384 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
14385 }
14386}
14387impl serde::Serialize for TableOption {
14388 #[allow(deprecated)]
14389 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14390 where
14391 S: serde::Serializer,
14392 {
14393 use serde::ser::SerializeStruct;
14394 let mut len = 0;
14395 if self.retention_seconds.is_some() {
14396 len += 1;
14397 }
14398 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
14399 if let Some(v) = self.retention_seconds.as_ref() {
14400 struct_ser.serialize_field("retentionSeconds", v)?;
14401 }
14402 struct_ser.end()
14403 }
14404}
14405impl<'de> serde::Deserialize<'de> for TableOption {
14406 #[allow(deprecated)]
14407 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14408 where
14409 D: serde::Deserializer<'de>,
14410 {
14411 const FIELDS: &[&str] = &[
14412 "retention_seconds",
14413 "retentionSeconds",
14414 ];
14415
14416 #[allow(clippy::enum_variant_names)]
14417 enum GeneratedField {
14418 RetentionSeconds,
14419 }
14420 impl<'de> serde::Deserialize<'de> for GeneratedField {
14421 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14422 where
14423 D: serde::Deserializer<'de>,
14424 {
14425 struct GeneratedVisitor;
14426
14427 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14428 type Value = GeneratedField;
14429
14430 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14431 write!(formatter, "expected one of: {:?}", &FIELDS)
14432 }
14433
14434 #[allow(unused_variables)]
14435 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14436 where
14437 E: serde::de::Error,
14438 {
14439 match value {
14440 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
14441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14442 }
14443 }
14444 }
14445 deserializer.deserialize_identifier(GeneratedVisitor)
14446 }
14447 }
14448 struct GeneratedVisitor;
14449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14450 type Value = TableOption;
14451
14452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14453 formatter.write_str("struct hummock.TableOption")
14454 }
14455
14456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
14457 where
14458 V: serde::de::MapAccess<'de>,
14459 {
14460 let mut retention_seconds__ = None;
14461 while let Some(k) = map_.next_key()? {
14462 match k {
14463 GeneratedField::RetentionSeconds => {
14464 if retention_seconds__.is_some() {
14465 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
14466 }
14467 retention_seconds__ =
14468 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14469 ;
14470 }
14471 }
14472 }
14473 Ok(TableOption {
14474 retention_seconds: retention_seconds__,
14475 })
14476 }
14477 }
14478 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
14479 }
14480}
14481impl serde::Serialize for TableSchema {
14482 #[allow(deprecated)]
14483 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14484 where
14485 S: serde::Serializer,
14486 {
14487 use serde::ser::SerializeStruct;
14488 let mut len = 0;
14489 if !self.column_ids.is_empty() {
14490 len += 1;
14491 }
14492 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
14493 if !self.column_ids.is_empty() {
14494 struct_ser.serialize_field("columnIds", &self.column_ids)?;
14495 }
14496 struct_ser.end()
14497 }
14498}
14499impl<'de> serde::Deserialize<'de> for TableSchema {
14500 #[allow(deprecated)]
14501 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14502 where
14503 D: serde::Deserializer<'de>,
14504 {
14505 const FIELDS: &[&str] = &[
14506 "column_ids",
14507 "columnIds",
14508 ];
14509
14510 #[allow(clippy::enum_variant_names)]
14511 enum GeneratedField {
14512 ColumnIds,
14513 }
14514 impl<'de> serde::Deserialize<'de> for GeneratedField {
14515 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14516 where
14517 D: serde::Deserializer<'de>,
14518 {
14519 struct GeneratedVisitor;
14520
14521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14522 type Value = GeneratedField;
14523
14524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14525 write!(formatter, "expected one of: {:?}", &FIELDS)
14526 }
14527
14528 #[allow(unused_variables)]
14529 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14530 where
14531 E: serde::de::Error,
14532 {
14533 match value {
14534 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
14535 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14536 }
14537 }
14538 }
14539 deserializer.deserialize_identifier(GeneratedVisitor)
14540 }
14541 }
14542 struct GeneratedVisitor;
14543 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14544 type Value = TableSchema;
14545
14546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14547 formatter.write_str("struct hummock.TableSchema")
14548 }
14549
14550 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
14551 where
14552 V: serde::de::MapAccess<'de>,
14553 {
14554 let mut column_ids__ = None;
14555 while let Some(k) = map_.next_key()? {
14556 match k {
14557 GeneratedField::ColumnIds => {
14558 if column_ids__.is_some() {
14559 return Err(serde::de::Error::duplicate_field("columnIds"));
14560 }
14561 column_ids__ =
14562 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14563 .into_iter().map(|x| x.0).collect())
14564 ;
14565 }
14566 }
14567 }
14568 Ok(TableSchema {
14569 column_ids: column_ids__.unwrap_or_default(),
14570 })
14571 }
14572 }
14573 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
14574 }
14575}
14576impl serde::Serialize for TableStats {
14577 #[allow(deprecated)]
14578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14579 where
14580 S: serde::Serializer,
14581 {
14582 use serde::ser::SerializeStruct;
14583 let mut len = 0;
14584 if self.total_key_size != 0 {
14585 len += 1;
14586 }
14587 if self.total_value_size != 0 {
14588 len += 1;
14589 }
14590 if self.total_key_count != 0 {
14591 len += 1;
14592 }
14593 if self.total_compressed_size != 0 {
14594 len += 1;
14595 }
14596 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
14597 if self.total_key_size != 0 {
14598 #[allow(clippy::needless_borrow)]
14599 #[allow(clippy::needless_borrows_for_generic_args)]
14600 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
14601 }
14602 if self.total_value_size != 0 {
14603 #[allow(clippy::needless_borrow)]
14604 #[allow(clippy::needless_borrows_for_generic_args)]
14605 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
14606 }
14607 if self.total_key_count != 0 {
14608 #[allow(clippy::needless_borrow)]
14609 #[allow(clippy::needless_borrows_for_generic_args)]
14610 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
14611 }
14612 if self.total_compressed_size != 0 {
14613 #[allow(clippy::needless_borrow)]
14614 #[allow(clippy::needless_borrows_for_generic_args)]
14615 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
14616 }
14617 struct_ser.end()
14618 }
14619}
14620impl<'de> serde::Deserialize<'de> for TableStats {
14621 #[allow(deprecated)]
14622 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14623 where
14624 D: serde::Deserializer<'de>,
14625 {
14626 const FIELDS: &[&str] = &[
14627 "total_key_size",
14628 "totalKeySize",
14629 "total_value_size",
14630 "totalValueSize",
14631 "total_key_count",
14632 "totalKeyCount",
14633 "total_compressed_size",
14634 "totalCompressedSize",
14635 ];
14636
14637 #[allow(clippy::enum_variant_names)]
14638 enum GeneratedField {
14639 TotalKeySize,
14640 TotalValueSize,
14641 TotalKeyCount,
14642 TotalCompressedSize,
14643 }
14644 impl<'de> serde::Deserialize<'de> for GeneratedField {
14645 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14646 where
14647 D: serde::Deserializer<'de>,
14648 {
14649 struct GeneratedVisitor;
14650
14651 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14652 type Value = GeneratedField;
14653
14654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14655 write!(formatter, "expected one of: {:?}", &FIELDS)
14656 }
14657
14658 #[allow(unused_variables)]
14659 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14660 where
14661 E: serde::de::Error,
14662 {
14663 match value {
14664 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
14665 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
14666 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
14667 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
14668 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14669 }
14670 }
14671 }
14672 deserializer.deserialize_identifier(GeneratedVisitor)
14673 }
14674 }
14675 struct GeneratedVisitor;
14676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14677 type Value = TableStats;
14678
14679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14680 formatter.write_str("struct hummock.TableStats")
14681 }
14682
14683 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
14684 where
14685 V: serde::de::MapAccess<'de>,
14686 {
14687 let mut total_key_size__ = None;
14688 let mut total_value_size__ = None;
14689 let mut total_key_count__ = None;
14690 let mut total_compressed_size__ = None;
14691 while let Some(k) = map_.next_key()? {
14692 match k {
14693 GeneratedField::TotalKeySize => {
14694 if total_key_size__.is_some() {
14695 return Err(serde::de::Error::duplicate_field("totalKeySize"));
14696 }
14697 total_key_size__ =
14698 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14699 ;
14700 }
14701 GeneratedField::TotalValueSize => {
14702 if total_value_size__.is_some() {
14703 return Err(serde::de::Error::duplicate_field("totalValueSize"));
14704 }
14705 total_value_size__ =
14706 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14707 ;
14708 }
14709 GeneratedField::TotalKeyCount => {
14710 if total_key_count__.is_some() {
14711 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
14712 }
14713 total_key_count__ =
14714 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14715 ;
14716 }
14717 GeneratedField::TotalCompressedSize => {
14718 if total_compressed_size__.is_some() {
14719 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
14720 }
14721 total_compressed_size__ =
14722 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14723 ;
14724 }
14725 }
14726 }
14727 Ok(TableStats {
14728 total_key_size: total_key_size__.unwrap_or_default(),
14729 total_value_size: total_value_size__.unwrap_or_default(),
14730 total_key_count: total_key_count__.unwrap_or_default(),
14731 total_compressed_size: total_compressed_size__.unwrap_or_default(),
14732 })
14733 }
14734 }
14735 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
14736 }
14737}
14738impl serde::Serialize for TableWatermarks {
14739 #[allow(deprecated)]
14740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14741 where
14742 S: serde::Serializer,
14743 {
14744 use serde::ser::SerializeStruct;
14745 let mut len = 0;
14746 if !self.epoch_watermarks.is_empty() {
14747 len += 1;
14748 }
14749 if self.is_ascending {
14750 len += 1;
14751 }
14752 if self.is_non_pk_prefix {
14753 len += 1;
14754 }
14755 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
14756 if !self.epoch_watermarks.is_empty() {
14757 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
14758 }
14759 if self.is_ascending {
14760 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
14761 }
14762 if self.is_non_pk_prefix {
14763 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
14764 }
14765 struct_ser.end()
14766 }
14767}
14768impl<'de> serde::Deserialize<'de> for TableWatermarks {
14769 #[allow(deprecated)]
14770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14771 where
14772 D: serde::Deserializer<'de>,
14773 {
14774 const FIELDS: &[&str] = &[
14775 "epoch_watermarks",
14776 "epochWatermarks",
14777 "is_ascending",
14778 "isAscending",
14779 "is_non_pk_prefix",
14780 "isNonPkPrefix",
14781 ];
14782
14783 #[allow(clippy::enum_variant_names)]
14784 enum GeneratedField {
14785 EpochWatermarks,
14786 IsAscending,
14787 IsNonPkPrefix,
14788 }
14789 impl<'de> serde::Deserialize<'de> for GeneratedField {
14790 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14791 where
14792 D: serde::Deserializer<'de>,
14793 {
14794 struct GeneratedVisitor;
14795
14796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14797 type Value = GeneratedField;
14798
14799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14800 write!(formatter, "expected one of: {:?}", &FIELDS)
14801 }
14802
14803 #[allow(unused_variables)]
14804 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14805 where
14806 E: serde::de::Error,
14807 {
14808 match value {
14809 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
14810 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
14811 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
14812 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14813 }
14814 }
14815 }
14816 deserializer.deserialize_identifier(GeneratedVisitor)
14817 }
14818 }
14819 struct GeneratedVisitor;
14820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14821 type Value = TableWatermarks;
14822
14823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14824 formatter.write_str("struct hummock.TableWatermarks")
14825 }
14826
14827 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
14828 where
14829 V: serde::de::MapAccess<'de>,
14830 {
14831 let mut epoch_watermarks__ = None;
14832 let mut is_ascending__ = None;
14833 let mut is_non_pk_prefix__ = None;
14834 while let Some(k) = map_.next_key()? {
14835 match k {
14836 GeneratedField::EpochWatermarks => {
14837 if epoch_watermarks__.is_some() {
14838 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
14839 }
14840 epoch_watermarks__ = Some(map_.next_value()?);
14841 }
14842 GeneratedField::IsAscending => {
14843 if is_ascending__.is_some() {
14844 return Err(serde::de::Error::duplicate_field("isAscending"));
14845 }
14846 is_ascending__ = Some(map_.next_value()?);
14847 }
14848 GeneratedField::IsNonPkPrefix => {
14849 if is_non_pk_prefix__.is_some() {
14850 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
14851 }
14852 is_non_pk_prefix__ = Some(map_.next_value()?);
14853 }
14854 }
14855 }
14856 Ok(TableWatermarks {
14857 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
14858 is_ascending: is_ascending__.unwrap_or_default(),
14859 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
14860 })
14861 }
14862 }
14863 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
14864 }
14865}
14866impl serde::Serialize for table_watermarks::EpochNewWatermarks {
14867 #[allow(deprecated)]
14868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14869 where
14870 S: serde::Serializer,
14871 {
14872 use serde::ser::SerializeStruct;
14873 let mut len = 0;
14874 if !self.watermarks.is_empty() {
14875 len += 1;
14876 }
14877 if self.epoch != 0 {
14878 len += 1;
14879 }
14880 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
14881 if !self.watermarks.is_empty() {
14882 struct_ser.serialize_field("watermarks", &self.watermarks)?;
14883 }
14884 if self.epoch != 0 {
14885 #[allow(clippy::needless_borrow)]
14886 #[allow(clippy::needless_borrows_for_generic_args)]
14887 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
14888 }
14889 struct_ser.end()
14890 }
14891}
14892impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
14893 #[allow(deprecated)]
14894 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14895 where
14896 D: serde::Deserializer<'de>,
14897 {
14898 const FIELDS: &[&str] = &[
14899 "watermarks",
14900 "epoch",
14901 ];
14902
14903 #[allow(clippy::enum_variant_names)]
14904 enum GeneratedField {
14905 Watermarks,
14906 Epoch,
14907 }
14908 impl<'de> serde::Deserialize<'de> for GeneratedField {
14909 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14910 where
14911 D: serde::Deserializer<'de>,
14912 {
14913 struct GeneratedVisitor;
14914
14915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14916 type Value = GeneratedField;
14917
14918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14919 write!(formatter, "expected one of: {:?}", &FIELDS)
14920 }
14921
14922 #[allow(unused_variables)]
14923 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14924 where
14925 E: serde::de::Error,
14926 {
14927 match value {
14928 "watermarks" => Ok(GeneratedField::Watermarks),
14929 "epoch" => Ok(GeneratedField::Epoch),
14930 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14931 }
14932 }
14933 }
14934 deserializer.deserialize_identifier(GeneratedVisitor)
14935 }
14936 }
14937 struct GeneratedVisitor;
14938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14939 type Value = table_watermarks::EpochNewWatermarks;
14940
14941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14942 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
14943 }
14944
14945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
14946 where
14947 V: serde::de::MapAccess<'de>,
14948 {
14949 let mut watermarks__ = None;
14950 let mut epoch__ = None;
14951 while let Some(k) = map_.next_key()? {
14952 match k {
14953 GeneratedField::Watermarks => {
14954 if watermarks__.is_some() {
14955 return Err(serde::de::Error::duplicate_field("watermarks"));
14956 }
14957 watermarks__ = Some(map_.next_value()?);
14958 }
14959 GeneratedField::Epoch => {
14960 if epoch__.is_some() {
14961 return Err(serde::de::Error::duplicate_field("epoch"));
14962 }
14963 epoch__ =
14964 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14965 ;
14966 }
14967 }
14968 }
14969 Ok(table_watermarks::EpochNewWatermarks {
14970 watermarks: watermarks__.unwrap_or_default(),
14971 epoch: epoch__.unwrap_or_default(),
14972 })
14973 }
14974 }
14975 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
14976 }
14977}
14978impl serde::Serialize for TriggerCompactionDeterministicRequest {
14979 #[allow(deprecated)]
14980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14981 where
14982 S: serde::Serializer,
14983 {
14984 use serde::ser::SerializeStruct;
14985 let mut len = 0;
14986 if self.version_id != 0 {
14987 len += 1;
14988 }
14989 if !self.compaction_groups.is_empty() {
14990 len += 1;
14991 }
14992 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
14993 if self.version_id != 0 {
14994 #[allow(clippy::needless_borrow)]
14995 #[allow(clippy::needless_borrows_for_generic_args)]
14996 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
14997 }
14998 if !self.compaction_groups.is_empty() {
14999 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15000 }
15001 struct_ser.end()
15002 }
15003}
15004impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
15005 #[allow(deprecated)]
15006 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15007 where
15008 D: serde::Deserializer<'de>,
15009 {
15010 const FIELDS: &[&str] = &[
15011 "version_id",
15012 "versionId",
15013 "compaction_groups",
15014 "compactionGroups",
15015 ];
15016
15017 #[allow(clippy::enum_variant_names)]
15018 enum GeneratedField {
15019 VersionId,
15020 CompactionGroups,
15021 }
15022 impl<'de> serde::Deserialize<'de> for GeneratedField {
15023 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15024 where
15025 D: serde::Deserializer<'de>,
15026 {
15027 struct GeneratedVisitor;
15028
15029 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15030 type Value = GeneratedField;
15031
15032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15033 write!(formatter, "expected one of: {:?}", &FIELDS)
15034 }
15035
15036 #[allow(unused_variables)]
15037 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15038 where
15039 E: serde::de::Error,
15040 {
15041 match value {
15042 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
15043 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
15044 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15045 }
15046 }
15047 }
15048 deserializer.deserialize_identifier(GeneratedVisitor)
15049 }
15050 }
15051 struct GeneratedVisitor;
15052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15053 type Value = TriggerCompactionDeterministicRequest;
15054
15055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15056 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
15057 }
15058
15059 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
15060 where
15061 V: serde::de::MapAccess<'de>,
15062 {
15063 let mut version_id__ = None;
15064 let mut compaction_groups__ = None;
15065 while let Some(k) = map_.next_key()? {
15066 match k {
15067 GeneratedField::VersionId => {
15068 if version_id__.is_some() {
15069 return Err(serde::de::Error::duplicate_field("versionId"));
15070 }
15071 version_id__ =
15072 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15073 ;
15074 }
15075 GeneratedField::CompactionGroups => {
15076 if compaction_groups__.is_some() {
15077 return Err(serde::de::Error::duplicate_field("compactionGroups"));
15078 }
15079 compaction_groups__ =
15080 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15081 .into_iter().map(|x| x.0).collect())
15082 ;
15083 }
15084 }
15085 }
15086 Ok(TriggerCompactionDeterministicRequest {
15087 version_id: version_id__.unwrap_or_default(),
15088 compaction_groups: compaction_groups__.unwrap_or_default(),
15089 })
15090 }
15091 }
15092 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
15093 }
15094}
15095impl serde::Serialize for TriggerCompactionDeterministicResponse {
15096 #[allow(deprecated)]
15097 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15098 where
15099 S: serde::Serializer,
15100 {
15101 use serde::ser::SerializeStruct;
15102 let len = 0;
15103 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
15104 struct_ser.end()
15105 }
15106}
15107impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
15108 #[allow(deprecated)]
15109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15110 where
15111 D: serde::Deserializer<'de>,
15112 {
15113 const FIELDS: &[&str] = &[
15114 ];
15115
15116 #[allow(clippy::enum_variant_names)]
15117 enum GeneratedField {
15118 }
15119 impl<'de> serde::Deserialize<'de> for GeneratedField {
15120 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15121 where
15122 D: serde::Deserializer<'de>,
15123 {
15124 struct GeneratedVisitor;
15125
15126 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15127 type Value = GeneratedField;
15128
15129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15130 write!(formatter, "expected one of: {:?}", &FIELDS)
15131 }
15132
15133 #[allow(unused_variables)]
15134 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15135 where
15136 E: serde::de::Error,
15137 {
15138 Err(serde::de::Error::unknown_field(value, FIELDS))
15139 }
15140 }
15141 deserializer.deserialize_identifier(GeneratedVisitor)
15142 }
15143 }
15144 struct GeneratedVisitor;
15145 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15146 type Value = TriggerCompactionDeterministicResponse;
15147
15148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15149 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
15150 }
15151
15152 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
15153 where
15154 V: serde::de::MapAccess<'de>,
15155 {
15156 while map_.next_key::<GeneratedField>()?.is_some() {
15157 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15158 }
15159 Ok(TriggerCompactionDeterministicResponse {
15160 })
15161 }
15162 }
15163 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
15164 }
15165}
15166impl serde::Serialize for TriggerFullGcRequest {
15167 #[allow(deprecated)]
15168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15169 where
15170 S: serde::Serializer,
15171 {
15172 use serde::ser::SerializeStruct;
15173 let mut len = 0;
15174 if self.sst_retention_time_sec != 0 {
15175 len += 1;
15176 }
15177 if self.prefix.is_some() {
15178 len += 1;
15179 }
15180 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
15181 if self.sst_retention_time_sec != 0 {
15182 #[allow(clippy::needless_borrow)]
15183 #[allow(clippy::needless_borrows_for_generic_args)]
15184 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
15185 }
15186 if let Some(v) = self.prefix.as_ref() {
15187 struct_ser.serialize_field("prefix", v)?;
15188 }
15189 struct_ser.end()
15190 }
15191}
15192impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
15193 #[allow(deprecated)]
15194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15195 where
15196 D: serde::Deserializer<'de>,
15197 {
15198 const FIELDS: &[&str] = &[
15199 "sst_retention_time_sec",
15200 "sstRetentionTimeSec",
15201 "prefix",
15202 ];
15203
15204 #[allow(clippy::enum_variant_names)]
15205 enum GeneratedField {
15206 SstRetentionTimeSec,
15207 Prefix,
15208 }
15209 impl<'de> serde::Deserialize<'de> for GeneratedField {
15210 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15211 where
15212 D: serde::Deserializer<'de>,
15213 {
15214 struct GeneratedVisitor;
15215
15216 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15217 type Value = GeneratedField;
15218
15219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15220 write!(formatter, "expected one of: {:?}", &FIELDS)
15221 }
15222
15223 #[allow(unused_variables)]
15224 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15225 where
15226 E: serde::de::Error,
15227 {
15228 match value {
15229 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
15230 "prefix" => Ok(GeneratedField::Prefix),
15231 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15232 }
15233 }
15234 }
15235 deserializer.deserialize_identifier(GeneratedVisitor)
15236 }
15237 }
15238 struct GeneratedVisitor;
15239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15240 type Value = TriggerFullGcRequest;
15241
15242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15243 formatter.write_str("struct hummock.TriggerFullGCRequest")
15244 }
15245
15246 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
15247 where
15248 V: serde::de::MapAccess<'de>,
15249 {
15250 let mut sst_retention_time_sec__ = None;
15251 let mut prefix__ = None;
15252 while let Some(k) = map_.next_key()? {
15253 match k {
15254 GeneratedField::SstRetentionTimeSec => {
15255 if sst_retention_time_sec__.is_some() {
15256 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
15257 }
15258 sst_retention_time_sec__ =
15259 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15260 ;
15261 }
15262 GeneratedField::Prefix => {
15263 if prefix__.is_some() {
15264 return Err(serde::de::Error::duplicate_field("prefix"));
15265 }
15266 prefix__ = map_.next_value()?;
15267 }
15268 }
15269 }
15270 Ok(TriggerFullGcRequest {
15271 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
15272 prefix: prefix__,
15273 })
15274 }
15275 }
15276 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
15277 }
15278}
15279impl serde::Serialize for TriggerFullGcResponse {
15280 #[allow(deprecated)]
15281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15282 where
15283 S: serde::Serializer,
15284 {
15285 use serde::ser::SerializeStruct;
15286 let mut len = 0;
15287 if self.status.is_some() {
15288 len += 1;
15289 }
15290 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
15291 if let Some(v) = self.status.as_ref() {
15292 struct_ser.serialize_field("status", v)?;
15293 }
15294 struct_ser.end()
15295 }
15296}
15297impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
15298 #[allow(deprecated)]
15299 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15300 where
15301 D: serde::Deserializer<'de>,
15302 {
15303 const FIELDS: &[&str] = &[
15304 "status",
15305 ];
15306
15307 #[allow(clippy::enum_variant_names)]
15308 enum GeneratedField {
15309 Status,
15310 }
15311 impl<'de> serde::Deserialize<'de> for GeneratedField {
15312 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15313 where
15314 D: serde::Deserializer<'de>,
15315 {
15316 struct GeneratedVisitor;
15317
15318 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15319 type Value = GeneratedField;
15320
15321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15322 write!(formatter, "expected one of: {:?}", &FIELDS)
15323 }
15324
15325 #[allow(unused_variables)]
15326 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15327 where
15328 E: serde::de::Error,
15329 {
15330 match value {
15331 "status" => Ok(GeneratedField::Status),
15332 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15333 }
15334 }
15335 }
15336 deserializer.deserialize_identifier(GeneratedVisitor)
15337 }
15338 }
15339 struct GeneratedVisitor;
15340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15341 type Value = TriggerFullGcResponse;
15342
15343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15344 formatter.write_str("struct hummock.TriggerFullGCResponse")
15345 }
15346
15347 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
15348 where
15349 V: serde::de::MapAccess<'de>,
15350 {
15351 let mut status__ = None;
15352 while let Some(k) = map_.next_key()? {
15353 match k {
15354 GeneratedField::Status => {
15355 if status__.is_some() {
15356 return Err(serde::de::Error::duplicate_field("status"));
15357 }
15358 status__ = map_.next_value()?;
15359 }
15360 }
15361 }
15362 Ok(TriggerFullGcResponse {
15363 status: status__,
15364 })
15365 }
15366 }
15367 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
15368 }
15369}
15370impl serde::Serialize for TriggerManualCompactionRequest {
15371 #[allow(deprecated)]
15372 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15373 where
15374 S: serde::Serializer,
15375 {
15376 use serde::ser::SerializeStruct;
15377 let mut len = 0;
15378 if self.compaction_group_id != 0 {
15379 len += 1;
15380 }
15381 if self.key_range.is_some() {
15382 len += 1;
15383 }
15384 if self.table_id != 0 {
15385 len += 1;
15386 }
15387 if self.level != 0 {
15388 len += 1;
15389 }
15390 if !self.sst_ids.is_empty() {
15391 len += 1;
15392 }
15393 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
15394 if self.compaction_group_id != 0 {
15395 #[allow(clippy::needless_borrow)]
15396 #[allow(clippy::needless_borrows_for_generic_args)]
15397 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
15398 }
15399 if let Some(v) = self.key_range.as_ref() {
15400 struct_ser.serialize_field("keyRange", v)?;
15401 }
15402 if self.table_id != 0 {
15403 struct_ser.serialize_field("tableId", &self.table_id)?;
15404 }
15405 if self.level != 0 {
15406 struct_ser.serialize_field("level", &self.level)?;
15407 }
15408 if !self.sst_ids.is_empty() {
15409 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15410 }
15411 struct_ser.end()
15412 }
15413}
15414impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
15415 #[allow(deprecated)]
15416 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15417 where
15418 D: serde::Deserializer<'de>,
15419 {
15420 const FIELDS: &[&str] = &[
15421 "compaction_group_id",
15422 "compactionGroupId",
15423 "key_range",
15424 "keyRange",
15425 "table_id",
15426 "tableId",
15427 "level",
15428 "sst_ids",
15429 "sstIds",
15430 ];
15431
15432 #[allow(clippy::enum_variant_names)]
15433 enum GeneratedField {
15434 CompactionGroupId,
15435 KeyRange,
15436 TableId,
15437 Level,
15438 SstIds,
15439 }
15440 impl<'de> serde::Deserialize<'de> for GeneratedField {
15441 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15442 where
15443 D: serde::Deserializer<'de>,
15444 {
15445 struct GeneratedVisitor;
15446
15447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15448 type Value = GeneratedField;
15449
15450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15451 write!(formatter, "expected one of: {:?}", &FIELDS)
15452 }
15453
15454 #[allow(unused_variables)]
15455 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15456 where
15457 E: serde::de::Error,
15458 {
15459 match value {
15460 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
15461 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
15462 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15463 "level" => Ok(GeneratedField::Level),
15464 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
15465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15466 }
15467 }
15468 }
15469 deserializer.deserialize_identifier(GeneratedVisitor)
15470 }
15471 }
15472 struct GeneratedVisitor;
15473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15474 type Value = TriggerManualCompactionRequest;
15475
15476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15477 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
15478 }
15479
15480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
15481 where
15482 V: serde::de::MapAccess<'de>,
15483 {
15484 let mut compaction_group_id__ = None;
15485 let mut key_range__ = None;
15486 let mut table_id__ = None;
15487 let mut level__ = None;
15488 let mut sst_ids__ = None;
15489 while let Some(k) = map_.next_key()? {
15490 match k {
15491 GeneratedField::CompactionGroupId => {
15492 if compaction_group_id__.is_some() {
15493 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
15494 }
15495 compaction_group_id__ =
15496 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15497 ;
15498 }
15499 GeneratedField::KeyRange => {
15500 if key_range__.is_some() {
15501 return Err(serde::de::Error::duplicate_field("keyRange"));
15502 }
15503 key_range__ = map_.next_value()?;
15504 }
15505 GeneratedField::TableId => {
15506 if table_id__.is_some() {
15507 return Err(serde::de::Error::duplicate_field("tableId"));
15508 }
15509 table_id__ =
15510 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15511 ;
15512 }
15513 GeneratedField::Level => {
15514 if level__.is_some() {
15515 return Err(serde::de::Error::duplicate_field("level"));
15516 }
15517 level__ =
15518 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15519 ;
15520 }
15521 GeneratedField::SstIds => {
15522 if sst_ids__.is_some() {
15523 return Err(serde::de::Error::duplicate_field("sstIds"));
15524 }
15525 sst_ids__ =
15526 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15527 .into_iter().map(|x| x.0).collect())
15528 ;
15529 }
15530 }
15531 }
15532 Ok(TriggerManualCompactionRequest {
15533 compaction_group_id: compaction_group_id__.unwrap_or_default(),
15534 key_range: key_range__,
15535 table_id: table_id__.unwrap_or_default(),
15536 level: level__.unwrap_or_default(),
15537 sst_ids: sst_ids__.unwrap_or_default(),
15538 })
15539 }
15540 }
15541 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
15542 }
15543}
15544impl serde::Serialize for TriggerManualCompactionResponse {
15545 #[allow(deprecated)]
15546 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15547 where
15548 S: serde::Serializer,
15549 {
15550 use serde::ser::SerializeStruct;
15551 let mut len = 0;
15552 if self.status.is_some() {
15553 len += 1;
15554 }
15555 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
15556 if let Some(v) = self.status.as_ref() {
15557 struct_ser.serialize_field("status", v)?;
15558 }
15559 struct_ser.end()
15560 }
15561}
15562impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
15563 #[allow(deprecated)]
15564 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15565 where
15566 D: serde::Deserializer<'de>,
15567 {
15568 const FIELDS: &[&str] = &[
15569 "status",
15570 ];
15571
15572 #[allow(clippy::enum_variant_names)]
15573 enum GeneratedField {
15574 Status,
15575 }
15576 impl<'de> serde::Deserialize<'de> for GeneratedField {
15577 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15578 where
15579 D: serde::Deserializer<'de>,
15580 {
15581 struct GeneratedVisitor;
15582
15583 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15584 type Value = GeneratedField;
15585
15586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15587 write!(formatter, "expected one of: {:?}", &FIELDS)
15588 }
15589
15590 #[allow(unused_variables)]
15591 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15592 where
15593 E: serde::de::Error,
15594 {
15595 match value {
15596 "status" => Ok(GeneratedField::Status),
15597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15598 }
15599 }
15600 }
15601 deserializer.deserialize_identifier(GeneratedVisitor)
15602 }
15603 }
15604 struct GeneratedVisitor;
15605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15606 type Value = TriggerManualCompactionResponse;
15607
15608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15609 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
15610 }
15611
15612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
15613 where
15614 V: serde::de::MapAccess<'de>,
15615 {
15616 let mut status__ = None;
15617 while let Some(k) = map_.next_key()? {
15618 match k {
15619 GeneratedField::Status => {
15620 if status__.is_some() {
15621 return Err(serde::de::Error::duplicate_field("status"));
15622 }
15623 status__ = map_.next_value()?;
15624 }
15625 }
15626 }
15627 Ok(TriggerManualCompactionResponse {
15628 status: status__,
15629 })
15630 }
15631 }
15632 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
15633 }
15634}
15635impl serde::Serialize for UnpinVersionBeforeRequest {
15636 #[allow(deprecated)]
15637 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15638 where
15639 S: serde::Serializer,
15640 {
15641 use serde::ser::SerializeStruct;
15642 let mut len = 0;
15643 if self.context_id != 0 {
15644 len += 1;
15645 }
15646 if self.unpin_version_before != 0 {
15647 len += 1;
15648 }
15649 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
15650 if self.context_id != 0 {
15651 struct_ser.serialize_field("contextId", &self.context_id)?;
15652 }
15653 if self.unpin_version_before != 0 {
15654 #[allow(clippy::needless_borrow)]
15655 #[allow(clippy::needless_borrows_for_generic_args)]
15656 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
15657 }
15658 struct_ser.end()
15659 }
15660}
15661impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
15662 #[allow(deprecated)]
15663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15664 where
15665 D: serde::Deserializer<'de>,
15666 {
15667 const FIELDS: &[&str] = &[
15668 "context_id",
15669 "contextId",
15670 "unpin_version_before",
15671 "unpinVersionBefore",
15672 ];
15673
15674 #[allow(clippy::enum_variant_names)]
15675 enum GeneratedField {
15676 ContextId,
15677 UnpinVersionBefore,
15678 }
15679 impl<'de> serde::Deserialize<'de> for GeneratedField {
15680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15681 where
15682 D: serde::Deserializer<'de>,
15683 {
15684 struct GeneratedVisitor;
15685
15686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15687 type Value = GeneratedField;
15688
15689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15690 write!(formatter, "expected one of: {:?}", &FIELDS)
15691 }
15692
15693 #[allow(unused_variables)]
15694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15695 where
15696 E: serde::de::Error,
15697 {
15698 match value {
15699 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15700 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
15701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15702 }
15703 }
15704 }
15705 deserializer.deserialize_identifier(GeneratedVisitor)
15706 }
15707 }
15708 struct GeneratedVisitor;
15709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15710 type Value = UnpinVersionBeforeRequest;
15711
15712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15713 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
15714 }
15715
15716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
15717 where
15718 V: serde::de::MapAccess<'de>,
15719 {
15720 let mut context_id__ = None;
15721 let mut unpin_version_before__ = None;
15722 while let Some(k) = map_.next_key()? {
15723 match k {
15724 GeneratedField::ContextId => {
15725 if context_id__.is_some() {
15726 return Err(serde::de::Error::duplicate_field("contextId"));
15727 }
15728 context_id__ =
15729 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15730 ;
15731 }
15732 GeneratedField::UnpinVersionBefore => {
15733 if unpin_version_before__.is_some() {
15734 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
15735 }
15736 unpin_version_before__ =
15737 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15738 ;
15739 }
15740 }
15741 }
15742 Ok(UnpinVersionBeforeRequest {
15743 context_id: context_id__.unwrap_or_default(),
15744 unpin_version_before: unpin_version_before__.unwrap_or_default(),
15745 })
15746 }
15747 }
15748 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
15749 }
15750}
15751impl serde::Serialize for UnpinVersionBeforeResponse {
15752 #[allow(deprecated)]
15753 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15754 where
15755 S: serde::Serializer,
15756 {
15757 use serde::ser::SerializeStruct;
15758 let mut len = 0;
15759 if self.status.is_some() {
15760 len += 1;
15761 }
15762 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
15763 if let Some(v) = self.status.as_ref() {
15764 struct_ser.serialize_field("status", v)?;
15765 }
15766 struct_ser.end()
15767 }
15768}
15769impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
15770 #[allow(deprecated)]
15771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15772 where
15773 D: serde::Deserializer<'de>,
15774 {
15775 const FIELDS: &[&str] = &[
15776 "status",
15777 ];
15778
15779 #[allow(clippy::enum_variant_names)]
15780 enum GeneratedField {
15781 Status,
15782 }
15783 impl<'de> serde::Deserialize<'de> for GeneratedField {
15784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15785 where
15786 D: serde::Deserializer<'de>,
15787 {
15788 struct GeneratedVisitor;
15789
15790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15791 type Value = GeneratedField;
15792
15793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15794 write!(formatter, "expected one of: {:?}", &FIELDS)
15795 }
15796
15797 #[allow(unused_variables)]
15798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15799 where
15800 E: serde::de::Error,
15801 {
15802 match value {
15803 "status" => Ok(GeneratedField::Status),
15804 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15805 }
15806 }
15807 }
15808 deserializer.deserialize_identifier(GeneratedVisitor)
15809 }
15810 }
15811 struct GeneratedVisitor;
15812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15813 type Value = UnpinVersionBeforeResponse;
15814
15815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15816 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
15817 }
15818
15819 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
15820 where
15821 V: serde::de::MapAccess<'de>,
15822 {
15823 let mut status__ = None;
15824 while let Some(k) = map_.next_key()? {
15825 match k {
15826 GeneratedField::Status => {
15827 if status__.is_some() {
15828 return Err(serde::de::Error::duplicate_field("status"));
15829 }
15830 status__ = map_.next_value()?;
15831 }
15832 }
15833 }
15834 Ok(UnpinVersionBeforeResponse {
15835 status: status__,
15836 })
15837 }
15838 }
15839 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
15840 }
15841}
15842impl serde::Serialize for UnpinVersionRequest {
15843 #[allow(deprecated)]
15844 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15845 where
15846 S: serde::Serializer,
15847 {
15848 use serde::ser::SerializeStruct;
15849 let mut len = 0;
15850 if self.context_id != 0 {
15851 len += 1;
15852 }
15853 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
15854 if self.context_id != 0 {
15855 struct_ser.serialize_field("contextId", &self.context_id)?;
15856 }
15857 struct_ser.end()
15858 }
15859}
15860impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
15861 #[allow(deprecated)]
15862 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15863 where
15864 D: serde::Deserializer<'de>,
15865 {
15866 const FIELDS: &[&str] = &[
15867 "context_id",
15868 "contextId",
15869 ];
15870
15871 #[allow(clippy::enum_variant_names)]
15872 enum GeneratedField {
15873 ContextId,
15874 }
15875 impl<'de> serde::Deserialize<'de> for GeneratedField {
15876 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15877 where
15878 D: serde::Deserializer<'de>,
15879 {
15880 struct GeneratedVisitor;
15881
15882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15883 type Value = GeneratedField;
15884
15885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15886 write!(formatter, "expected one of: {:?}", &FIELDS)
15887 }
15888
15889 #[allow(unused_variables)]
15890 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15891 where
15892 E: serde::de::Error,
15893 {
15894 match value {
15895 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15896 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15897 }
15898 }
15899 }
15900 deserializer.deserialize_identifier(GeneratedVisitor)
15901 }
15902 }
15903 struct GeneratedVisitor;
15904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15905 type Value = UnpinVersionRequest;
15906
15907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15908 formatter.write_str("struct hummock.UnpinVersionRequest")
15909 }
15910
15911 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
15912 where
15913 V: serde::de::MapAccess<'de>,
15914 {
15915 let mut context_id__ = None;
15916 while let Some(k) = map_.next_key()? {
15917 match k {
15918 GeneratedField::ContextId => {
15919 if context_id__.is_some() {
15920 return Err(serde::de::Error::duplicate_field("contextId"));
15921 }
15922 context_id__ =
15923 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15924 ;
15925 }
15926 }
15927 }
15928 Ok(UnpinVersionRequest {
15929 context_id: context_id__.unwrap_or_default(),
15930 })
15931 }
15932 }
15933 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
15934 }
15935}
15936impl serde::Serialize for UnpinVersionResponse {
15937 #[allow(deprecated)]
15938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15939 where
15940 S: serde::Serializer,
15941 {
15942 use serde::ser::SerializeStruct;
15943 let mut len = 0;
15944 if self.status.is_some() {
15945 len += 1;
15946 }
15947 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
15948 if let Some(v) = self.status.as_ref() {
15949 struct_ser.serialize_field("status", v)?;
15950 }
15951 struct_ser.end()
15952 }
15953}
15954impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
15955 #[allow(deprecated)]
15956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15957 where
15958 D: serde::Deserializer<'de>,
15959 {
15960 const FIELDS: &[&str] = &[
15961 "status",
15962 ];
15963
15964 #[allow(clippy::enum_variant_names)]
15965 enum GeneratedField {
15966 Status,
15967 }
15968 impl<'de> serde::Deserialize<'de> for GeneratedField {
15969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15970 where
15971 D: serde::Deserializer<'de>,
15972 {
15973 struct GeneratedVisitor;
15974
15975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15976 type Value = GeneratedField;
15977
15978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15979 write!(formatter, "expected one of: {:?}", &FIELDS)
15980 }
15981
15982 #[allow(unused_variables)]
15983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15984 where
15985 E: serde::de::Error,
15986 {
15987 match value {
15988 "status" => Ok(GeneratedField::Status),
15989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15990 }
15991 }
15992 }
15993 deserializer.deserialize_identifier(GeneratedVisitor)
15994 }
15995 }
15996 struct GeneratedVisitor;
15997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15998 type Value = UnpinVersionResponse;
15999
16000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16001 formatter.write_str("struct hummock.UnpinVersionResponse")
16002 }
16003
16004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
16005 where
16006 V: serde::de::MapAccess<'de>,
16007 {
16008 let mut status__ = None;
16009 while let Some(k) = map_.next_key()? {
16010 match k {
16011 GeneratedField::Status => {
16012 if status__.is_some() {
16013 return Err(serde::de::Error::duplicate_field("status"));
16014 }
16015 status__ = map_.next_value()?;
16016 }
16017 }
16018 }
16019 Ok(UnpinVersionResponse {
16020 status: status__,
16021 })
16022 }
16023 }
16024 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
16025 }
16026}
16027impl serde::Serialize for VacuumTask {
16028 #[allow(deprecated)]
16029 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16030 where
16031 S: serde::Serializer,
16032 {
16033 use serde::ser::SerializeStruct;
16034 let mut len = 0;
16035 if !self.sstable_object_ids.is_empty() {
16036 len += 1;
16037 }
16038 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
16039 if !self.sstable_object_ids.is_empty() {
16040 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16041 }
16042 struct_ser.end()
16043 }
16044}
16045impl<'de> serde::Deserialize<'de> for VacuumTask {
16046 #[allow(deprecated)]
16047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16048 where
16049 D: serde::Deserializer<'de>,
16050 {
16051 const FIELDS: &[&str] = &[
16052 "sstable_object_ids",
16053 "sstableObjectIds",
16054 ];
16055
16056 #[allow(clippy::enum_variant_names)]
16057 enum GeneratedField {
16058 SstableObjectIds,
16059 }
16060 impl<'de> serde::Deserialize<'de> for GeneratedField {
16061 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16062 where
16063 D: serde::Deserializer<'de>,
16064 {
16065 struct GeneratedVisitor;
16066
16067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16068 type Value = GeneratedField;
16069
16070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16071 write!(formatter, "expected one of: {:?}", &FIELDS)
16072 }
16073
16074 #[allow(unused_variables)]
16075 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16076 where
16077 E: serde::de::Error,
16078 {
16079 match value {
16080 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
16081 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16082 }
16083 }
16084 }
16085 deserializer.deserialize_identifier(GeneratedVisitor)
16086 }
16087 }
16088 struct GeneratedVisitor;
16089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16090 type Value = VacuumTask;
16091
16092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16093 formatter.write_str("struct hummock.VacuumTask")
16094 }
16095
16096 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
16097 where
16098 V: serde::de::MapAccess<'de>,
16099 {
16100 let mut sstable_object_ids__ = None;
16101 while let Some(k) = map_.next_key()? {
16102 match k {
16103 GeneratedField::SstableObjectIds => {
16104 if sstable_object_ids__.is_some() {
16105 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
16106 }
16107 sstable_object_ids__ =
16108 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16109 .into_iter().map(|x| x.0).collect())
16110 ;
16111 }
16112 }
16113 }
16114 Ok(VacuumTask {
16115 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
16116 })
16117 }
16118 }
16119 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
16120 }
16121}
16122impl serde::Serialize for ValidationTask {
16123 #[allow(deprecated)]
16124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16125 where
16126 S: serde::Serializer,
16127 {
16128 use serde::ser::SerializeStruct;
16129 let mut len = 0;
16130 if !self.sst_infos.is_empty() {
16131 len += 1;
16132 }
16133 if !self.sst_id_to_worker_id.is_empty() {
16134 len += 1;
16135 }
16136 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
16137 if !self.sst_infos.is_empty() {
16138 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
16139 }
16140 if !self.sst_id_to_worker_id.is_empty() {
16141 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
16142 }
16143 struct_ser.end()
16144 }
16145}
16146impl<'de> serde::Deserialize<'de> for ValidationTask {
16147 #[allow(deprecated)]
16148 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16149 where
16150 D: serde::Deserializer<'de>,
16151 {
16152 const FIELDS: &[&str] = &[
16153 "sst_infos",
16154 "sstInfos",
16155 "sst_id_to_worker_id",
16156 "sstIdToWorkerId",
16157 ];
16158
16159 #[allow(clippy::enum_variant_names)]
16160 enum GeneratedField {
16161 SstInfos,
16162 SstIdToWorkerId,
16163 }
16164 impl<'de> serde::Deserialize<'de> for GeneratedField {
16165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16166 where
16167 D: serde::Deserializer<'de>,
16168 {
16169 struct GeneratedVisitor;
16170
16171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16172 type Value = GeneratedField;
16173
16174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16175 write!(formatter, "expected one of: {:?}", &FIELDS)
16176 }
16177
16178 #[allow(unused_variables)]
16179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16180 where
16181 E: serde::de::Error,
16182 {
16183 match value {
16184 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
16185 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
16186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16187 }
16188 }
16189 }
16190 deserializer.deserialize_identifier(GeneratedVisitor)
16191 }
16192 }
16193 struct GeneratedVisitor;
16194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16195 type Value = ValidationTask;
16196
16197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16198 formatter.write_str("struct hummock.ValidationTask")
16199 }
16200
16201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
16202 where
16203 V: serde::de::MapAccess<'de>,
16204 {
16205 let mut sst_infos__ = None;
16206 let mut sst_id_to_worker_id__ = None;
16207 while let Some(k) = map_.next_key()? {
16208 match k {
16209 GeneratedField::SstInfos => {
16210 if sst_infos__.is_some() {
16211 return Err(serde::de::Error::duplicate_field("sstInfos"));
16212 }
16213 sst_infos__ = Some(map_.next_value()?);
16214 }
16215 GeneratedField::SstIdToWorkerId => {
16216 if sst_id_to_worker_id__.is_some() {
16217 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
16218 }
16219 sst_id_to_worker_id__ = Some(
16220 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
16221 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
16222 );
16223 }
16224 }
16225 }
16226 Ok(ValidationTask {
16227 sst_infos: sst_infos__.unwrap_or_default(),
16228 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
16229 })
16230 }
16231 }
16232 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
16233 }
16234}
16235impl serde::Serialize for VectorFileInfo {
16236 #[allow(deprecated)]
16237 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16238 where
16239 S: serde::Serializer,
16240 {
16241 use serde::ser::SerializeStruct;
16242 let mut len = 0;
16243 if self.object_id != 0 {
16244 len += 1;
16245 }
16246 if self.file_size != 0 {
16247 len += 1;
16248 }
16249 let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
16250 if self.object_id != 0 {
16251 #[allow(clippy::needless_borrow)]
16252 #[allow(clippy::needless_borrows_for_generic_args)]
16253 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
16254 }
16255 if self.file_size != 0 {
16256 #[allow(clippy::needless_borrow)]
16257 #[allow(clippy::needless_borrows_for_generic_args)]
16258 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
16259 }
16260 struct_ser.end()
16261 }
16262}
16263impl<'de> serde::Deserialize<'de> for VectorFileInfo {
16264 #[allow(deprecated)]
16265 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16266 where
16267 D: serde::Deserializer<'de>,
16268 {
16269 const FIELDS: &[&str] = &[
16270 "object_id",
16271 "objectId",
16272 "file_size",
16273 "fileSize",
16274 ];
16275
16276 #[allow(clippy::enum_variant_names)]
16277 enum GeneratedField {
16278 ObjectId,
16279 FileSize,
16280 }
16281 impl<'de> serde::Deserialize<'de> for GeneratedField {
16282 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16283 where
16284 D: serde::Deserializer<'de>,
16285 {
16286 struct GeneratedVisitor;
16287
16288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16289 type Value = GeneratedField;
16290
16291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16292 write!(formatter, "expected one of: {:?}", &FIELDS)
16293 }
16294
16295 #[allow(unused_variables)]
16296 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16297 where
16298 E: serde::de::Error,
16299 {
16300 match value {
16301 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
16302 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
16303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16304 }
16305 }
16306 }
16307 deserializer.deserialize_identifier(GeneratedVisitor)
16308 }
16309 }
16310 struct GeneratedVisitor;
16311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16312 type Value = VectorFileInfo;
16313
16314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16315 formatter.write_str("struct hummock.VectorFileInfo")
16316 }
16317
16318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
16319 where
16320 V: serde::de::MapAccess<'de>,
16321 {
16322 let mut object_id__ = None;
16323 let mut file_size__ = None;
16324 while let Some(k) = map_.next_key()? {
16325 match k {
16326 GeneratedField::ObjectId => {
16327 if object_id__.is_some() {
16328 return Err(serde::de::Error::duplicate_field("objectId"));
16329 }
16330 object_id__ =
16331 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16332 ;
16333 }
16334 GeneratedField::FileSize => {
16335 if file_size__.is_some() {
16336 return Err(serde::de::Error::duplicate_field("fileSize"));
16337 }
16338 file_size__ =
16339 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16340 ;
16341 }
16342 }
16343 }
16344 Ok(VectorFileInfo {
16345 object_id: object_id__.unwrap_or_default(),
16346 file_size: file_size__.unwrap_or_default(),
16347 })
16348 }
16349 }
16350 deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
16351 }
16352}
16353impl serde::Serialize for VectorIndex {
16354 #[allow(deprecated)]
16355 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16356 where
16357 S: serde::Serializer,
16358 {
16359 use serde::ser::SerializeStruct;
16360 let mut len = 0;
16361 if self.dimension != 0 {
16362 len += 1;
16363 }
16364 if self.distance_type != 0 {
16365 len += 1;
16366 }
16367 if self.variant.is_some() {
16368 len += 1;
16369 }
16370 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
16371 if self.dimension != 0 {
16372 struct_ser.serialize_field("dimension", &self.dimension)?;
16373 }
16374 if self.distance_type != 0 {
16375 let v = DistanceType::try_from(self.distance_type)
16376 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
16377 struct_ser.serialize_field("distanceType", &v)?;
16378 }
16379 if let Some(v) = self.variant.as_ref() {
16380 match v {
16381 vector_index::Variant::Flat(v) => {
16382 struct_ser.serialize_field("flat", v)?;
16383 }
16384 }
16385 }
16386 struct_ser.end()
16387 }
16388}
16389impl<'de> serde::Deserialize<'de> for VectorIndex {
16390 #[allow(deprecated)]
16391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16392 where
16393 D: serde::Deserializer<'de>,
16394 {
16395 const FIELDS: &[&str] = &[
16396 "dimension",
16397 "distance_type",
16398 "distanceType",
16399 "flat",
16400 ];
16401
16402 #[allow(clippy::enum_variant_names)]
16403 enum GeneratedField {
16404 Dimension,
16405 DistanceType,
16406 Flat,
16407 }
16408 impl<'de> serde::Deserialize<'de> for GeneratedField {
16409 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16410 where
16411 D: serde::Deserializer<'de>,
16412 {
16413 struct GeneratedVisitor;
16414
16415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16416 type Value = GeneratedField;
16417
16418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16419 write!(formatter, "expected one of: {:?}", &FIELDS)
16420 }
16421
16422 #[allow(unused_variables)]
16423 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16424 where
16425 E: serde::de::Error,
16426 {
16427 match value {
16428 "dimension" => Ok(GeneratedField::Dimension),
16429 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
16430 "flat" => Ok(GeneratedField::Flat),
16431 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16432 }
16433 }
16434 }
16435 deserializer.deserialize_identifier(GeneratedVisitor)
16436 }
16437 }
16438 struct GeneratedVisitor;
16439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16440 type Value = VectorIndex;
16441
16442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16443 formatter.write_str("struct hummock.VectorIndex")
16444 }
16445
16446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
16447 where
16448 V: serde::de::MapAccess<'de>,
16449 {
16450 let mut dimension__ = None;
16451 let mut distance_type__ = None;
16452 let mut variant__ = None;
16453 while let Some(k) = map_.next_key()? {
16454 match k {
16455 GeneratedField::Dimension => {
16456 if dimension__.is_some() {
16457 return Err(serde::de::Error::duplicate_field("dimension"));
16458 }
16459 dimension__ =
16460 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16461 ;
16462 }
16463 GeneratedField::DistanceType => {
16464 if distance_type__.is_some() {
16465 return Err(serde::de::Error::duplicate_field("distanceType"));
16466 }
16467 distance_type__ = Some(map_.next_value::<DistanceType>()? as i32);
16468 }
16469 GeneratedField::Flat => {
16470 if variant__.is_some() {
16471 return Err(serde::de::Error::duplicate_field("flat"));
16472 }
16473 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
16474;
16475 }
16476 }
16477 }
16478 Ok(VectorIndex {
16479 dimension: dimension__.unwrap_or_default(),
16480 distance_type: distance_type__.unwrap_or_default(),
16481 variant: variant__,
16482 })
16483 }
16484 }
16485 deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
16486 }
16487}
16488impl serde::Serialize for VectorIndexDelta {
16489 #[allow(deprecated)]
16490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16491 where
16492 S: serde::Serializer,
16493 {
16494 use serde::ser::SerializeStruct;
16495 let mut len = 0;
16496 if self.delta.is_some() {
16497 len += 1;
16498 }
16499 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
16500 if let Some(v) = self.delta.as_ref() {
16501 match v {
16502 vector_index_delta::Delta::Init(v) => {
16503 struct_ser.serialize_field("init", v)?;
16504 }
16505 vector_index_delta::Delta::Adds(v) => {
16506 struct_ser.serialize_field("adds", v)?;
16507 }
16508 }
16509 }
16510 struct_ser.end()
16511 }
16512}
16513impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
16514 #[allow(deprecated)]
16515 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16516 where
16517 D: serde::Deserializer<'de>,
16518 {
16519 const FIELDS: &[&str] = &[
16520 "init",
16521 "adds",
16522 ];
16523
16524 #[allow(clippy::enum_variant_names)]
16525 enum GeneratedField {
16526 Init,
16527 Adds,
16528 }
16529 impl<'de> serde::Deserialize<'de> for GeneratedField {
16530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16531 where
16532 D: serde::Deserializer<'de>,
16533 {
16534 struct GeneratedVisitor;
16535
16536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16537 type Value = GeneratedField;
16538
16539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16540 write!(formatter, "expected one of: {:?}", &FIELDS)
16541 }
16542
16543 #[allow(unused_variables)]
16544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16545 where
16546 E: serde::de::Error,
16547 {
16548 match value {
16549 "init" => Ok(GeneratedField::Init),
16550 "adds" => Ok(GeneratedField::Adds),
16551 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16552 }
16553 }
16554 }
16555 deserializer.deserialize_identifier(GeneratedVisitor)
16556 }
16557 }
16558 struct GeneratedVisitor;
16559 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16560 type Value = VectorIndexDelta;
16561
16562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16563 formatter.write_str("struct hummock.VectorIndexDelta")
16564 }
16565
16566 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
16567 where
16568 V: serde::de::MapAccess<'de>,
16569 {
16570 let mut delta__ = None;
16571 while let Some(k) = map_.next_key()? {
16572 match k {
16573 GeneratedField::Init => {
16574 if delta__.is_some() {
16575 return Err(serde::de::Error::duplicate_field("init"));
16576 }
16577 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
16578;
16579 }
16580 GeneratedField::Adds => {
16581 if delta__.is_some() {
16582 return Err(serde::de::Error::duplicate_field("adds"));
16583 }
16584 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
16585;
16586 }
16587 }
16588 }
16589 Ok(VectorIndexDelta {
16590 delta: delta__,
16591 })
16592 }
16593 }
16594 deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
16595 }
16596}
16597impl serde::Serialize for vector_index_delta::VectorIndexAdd {
16598 #[allow(deprecated)]
16599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16600 where
16601 S: serde::Serializer,
16602 {
16603 use serde::ser::SerializeStruct;
16604 let mut len = 0;
16605 if self.add.is_some() {
16606 len += 1;
16607 }
16608 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
16609 if let Some(v) = self.add.as_ref() {
16610 match v {
16611 vector_index_delta::vector_index_add::Add::Flat(v) => {
16612 struct_ser.serialize_field("flat", v)?;
16613 }
16614 }
16615 }
16616 struct_ser.end()
16617 }
16618}
16619impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
16620 #[allow(deprecated)]
16621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16622 where
16623 D: serde::Deserializer<'de>,
16624 {
16625 const FIELDS: &[&str] = &[
16626 "flat",
16627 ];
16628
16629 #[allow(clippy::enum_variant_names)]
16630 enum GeneratedField {
16631 Flat,
16632 }
16633 impl<'de> serde::Deserialize<'de> for GeneratedField {
16634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16635 where
16636 D: serde::Deserializer<'de>,
16637 {
16638 struct GeneratedVisitor;
16639
16640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16641 type Value = GeneratedField;
16642
16643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16644 write!(formatter, "expected one of: {:?}", &FIELDS)
16645 }
16646
16647 #[allow(unused_variables)]
16648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16649 where
16650 E: serde::de::Error,
16651 {
16652 match value {
16653 "flat" => Ok(GeneratedField::Flat),
16654 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16655 }
16656 }
16657 }
16658 deserializer.deserialize_identifier(GeneratedVisitor)
16659 }
16660 }
16661 struct GeneratedVisitor;
16662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16663 type Value = vector_index_delta::VectorIndexAdd;
16664
16665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16666 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
16667 }
16668
16669 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
16670 where
16671 V: serde::de::MapAccess<'de>,
16672 {
16673 let mut add__ = None;
16674 while let Some(k) = map_.next_key()? {
16675 match k {
16676 GeneratedField::Flat => {
16677 if add__.is_some() {
16678 return Err(serde::de::Error::duplicate_field("flat"));
16679 }
16680 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
16681;
16682 }
16683 }
16684 }
16685 Ok(vector_index_delta::VectorIndexAdd {
16686 add: add__,
16687 })
16688 }
16689 }
16690 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
16691 }
16692}
16693impl serde::Serialize for vector_index_delta::VectorIndexAdds {
16694 #[allow(deprecated)]
16695 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16696 where
16697 S: serde::Serializer,
16698 {
16699 use serde::ser::SerializeStruct;
16700 let mut len = 0;
16701 if !self.adds.is_empty() {
16702 len += 1;
16703 }
16704 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
16705 if !self.adds.is_empty() {
16706 struct_ser.serialize_field("adds", &self.adds)?;
16707 }
16708 struct_ser.end()
16709 }
16710}
16711impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
16712 #[allow(deprecated)]
16713 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16714 where
16715 D: serde::Deserializer<'de>,
16716 {
16717 const FIELDS: &[&str] = &[
16718 "adds",
16719 ];
16720
16721 #[allow(clippy::enum_variant_names)]
16722 enum GeneratedField {
16723 Adds,
16724 }
16725 impl<'de> serde::Deserialize<'de> for GeneratedField {
16726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16727 where
16728 D: serde::Deserializer<'de>,
16729 {
16730 struct GeneratedVisitor;
16731
16732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16733 type Value = GeneratedField;
16734
16735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16736 write!(formatter, "expected one of: {:?}", &FIELDS)
16737 }
16738
16739 #[allow(unused_variables)]
16740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16741 where
16742 E: serde::de::Error,
16743 {
16744 match value {
16745 "adds" => Ok(GeneratedField::Adds),
16746 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16747 }
16748 }
16749 }
16750 deserializer.deserialize_identifier(GeneratedVisitor)
16751 }
16752 }
16753 struct GeneratedVisitor;
16754 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16755 type Value = vector_index_delta::VectorIndexAdds;
16756
16757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16758 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
16759 }
16760
16761 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
16762 where
16763 V: serde::de::MapAccess<'de>,
16764 {
16765 let mut adds__ = None;
16766 while let Some(k) = map_.next_key()? {
16767 match k {
16768 GeneratedField::Adds => {
16769 if adds__.is_some() {
16770 return Err(serde::de::Error::duplicate_field("adds"));
16771 }
16772 adds__ = Some(map_.next_value()?);
16773 }
16774 }
16775 }
16776 Ok(vector_index_delta::VectorIndexAdds {
16777 adds: adds__.unwrap_or_default(),
16778 })
16779 }
16780 }
16781 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
16782 }
16783}
16784impl serde::Serialize for vector_index_delta::VectorIndexInit {
16785 #[allow(deprecated)]
16786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16787 where
16788 S: serde::Serializer,
16789 {
16790 use serde::ser::SerializeStruct;
16791 let mut len = 0;
16792 if self.dimension != 0 {
16793 len += 1;
16794 }
16795 if self.distance_type != 0 {
16796 len += 1;
16797 }
16798 if self.config.is_some() {
16799 len += 1;
16800 }
16801 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
16802 if self.dimension != 0 {
16803 struct_ser.serialize_field("dimension", &self.dimension)?;
16804 }
16805 if self.distance_type != 0 {
16806 let v = DistanceType::try_from(self.distance_type)
16807 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
16808 struct_ser.serialize_field("distanceType", &v)?;
16809 }
16810 if let Some(v) = self.config.as_ref() {
16811 match v {
16812 vector_index_delta::vector_index_init::Config::Flat(v) => {
16813 struct_ser.serialize_field("flat", v)?;
16814 }
16815 }
16816 }
16817 struct_ser.end()
16818 }
16819}
16820impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
16821 #[allow(deprecated)]
16822 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16823 where
16824 D: serde::Deserializer<'de>,
16825 {
16826 const FIELDS: &[&str] = &[
16827 "dimension",
16828 "distance_type",
16829 "distanceType",
16830 "flat",
16831 ];
16832
16833 #[allow(clippy::enum_variant_names)]
16834 enum GeneratedField {
16835 Dimension,
16836 DistanceType,
16837 Flat,
16838 }
16839 impl<'de> serde::Deserialize<'de> for GeneratedField {
16840 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16841 where
16842 D: serde::Deserializer<'de>,
16843 {
16844 struct GeneratedVisitor;
16845
16846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16847 type Value = GeneratedField;
16848
16849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16850 write!(formatter, "expected one of: {:?}", &FIELDS)
16851 }
16852
16853 #[allow(unused_variables)]
16854 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16855 where
16856 E: serde::de::Error,
16857 {
16858 match value {
16859 "dimension" => Ok(GeneratedField::Dimension),
16860 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
16861 "flat" => Ok(GeneratedField::Flat),
16862 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16863 }
16864 }
16865 }
16866 deserializer.deserialize_identifier(GeneratedVisitor)
16867 }
16868 }
16869 struct GeneratedVisitor;
16870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16871 type Value = vector_index_delta::VectorIndexInit;
16872
16873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16874 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
16875 }
16876
16877 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
16878 where
16879 V: serde::de::MapAccess<'de>,
16880 {
16881 let mut dimension__ = None;
16882 let mut distance_type__ = None;
16883 let mut config__ = None;
16884 while let Some(k) = map_.next_key()? {
16885 match k {
16886 GeneratedField::Dimension => {
16887 if dimension__.is_some() {
16888 return Err(serde::de::Error::duplicate_field("dimension"));
16889 }
16890 dimension__ =
16891 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16892 ;
16893 }
16894 GeneratedField::DistanceType => {
16895 if distance_type__.is_some() {
16896 return Err(serde::de::Error::duplicate_field("distanceType"));
16897 }
16898 distance_type__ = Some(map_.next_value::<DistanceType>()? as i32);
16899 }
16900 GeneratedField::Flat => {
16901 if config__.is_some() {
16902 return Err(serde::de::Error::duplicate_field("flat"));
16903 }
16904 config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_init::Config::Flat)
16905;
16906 }
16907 }
16908 }
16909 Ok(vector_index_delta::VectorIndexInit {
16910 dimension: dimension__.unwrap_or_default(),
16911 distance_type: distance_type__.unwrap_or_default(),
16912 config: config__,
16913 })
16914 }
16915 }
16916 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
16917 }
16918}
16919impl serde::Serialize for VectorIndexObject {
16920 #[allow(deprecated)]
16921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16922 where
16923 S: serde::Serializer,
16924 {
16925 use serde::ser::SerializeStruct;
16926 let mut len = 0;
16927 if self.id != 0 {
16928 len += 1;
16929 }
16930 if self.object_type != 0 {
16931 len += 1;
16932 }
16933 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
16934 if self.id != 0 {
16935 #[allow(clippy::needless_borrow)]
16936 #[allow(clippy::needless_borrows_for_generic_args)]
16937 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
16938 }
16939 if self.object_type != 0 {
16940 let v = VectorIndexObjectType::try_from(self.object_type)
16941 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
16942 struct_ser.serialize_field("objectType", &v)?;
16943 }
16944 struct_ser.end()
16945 }
16946}
16947impl<'de> serde::Deserialize<'de> for VectorIndexObject {
16948 #[allow(deprecated)]
16949 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16950 where
16951 D: serde::Deserializer<'de>,
16952 {
16953 const FIELDS: &[&str] = &[
16954 "id",
16955 "object_type",
16956 "objectType",
16957 ];
16958
16959 #[allow(clippy::enum_variant_names)]
16960 enum GeneratedField {
16961 Id,
16962 ObjectType,
16963 }
16964 impl<'de> serde::Deserialize<'de> for GeneratedField {
16965 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16966 where
16967 D: serde::Deserializer<'de>,
16968 {
16969 struct GeneratedVisitor;
16970
16971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16972 type Value = GeneratedField;
16973
16974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16975 write!(formatter, "expected one of: {:?}", &FIELDS)
16976 }
16977
16978 #[allow(unused_variables)]
16979 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16980 where
16981 E: serde::de::Error,
16982 {
16983 match value {
16984 "id" => Ok(GeneratedField::Id),
16985 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
16986 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16987 }
16988 }
16989 }
16990 deserializer.deserialize_identifier(GeneratedVisitor)
16991 }
16992 }
16993 struct GeneratedVisitor;
16994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16995 type Value = VectorIndexObject;
16996
16997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16998 formatter.write_str("struct hummock.VectorIndexObject")
16999 }
17000
17001 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
17002 where
17003 V: serde::de::MapAccess<'de>,
17004 {
17005 let mut id__ = None;
17006 let mut object_type__ = None;
17007 while let Some(k) = map_.next_key()? {
17008 match k {
17009 GeneratedField::Id => {
17010 if id__.is_some() {
17011 return Err(serde::de::Error::duplicate_field("id"));
17012 }
17013 id__ =
17014 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17015 ;
17016 }
17017 GeneratedField::ObjectType => {
17018 if object_type__.is_some() {
17019 return Err(serde::de::Error::duplicate_field("objectType"));
17020 }
17021 object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
17022 }
17023 }
17024 }
17025 Ok(VectorIndexObject {
17026 id: id__.unwrap_or_default(),
17027 object_type: object_type__.unwrap_or_default(),
17028 })
17029 }
17030 }
17031 deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
17032 }
17033}
17034impl serde::Serialize for VectorIndexObjectType {
17035 #[allow(deprecated)]
17036 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17037 where
17038 S: serde::Serializer,
17039 {
17040 let variant = match self {
17041 Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17042 Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
17043 };
17044 serializer.serialize_str(variant)
17045 }
17046}
17047impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
17048 #[allow(deprecated)]
17049 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17050 where
17051 D: serde::Deserializer<'de>,
17052 {
17053 const FIELDS: &[&str] = &[
17054 "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17055 "VECTOR_INDEX_OBJECT_VECTOR",
17056 ];
17057
17058 struct GeneratedVisitor;
17059
17060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17061 type Value = VectorIndexObjectType;
17062
17063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17064 write!(formatter, "expected one of: {:?}", &FIELDS)
17065 }
17066
17067 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17068 where
17069 E: serde::de::Error,
17070 {
17071 i32::try_from(v)
17072 .ok()
17073 .and_then(|x| x.try_into().ok())
17074 .ok_or_else(|| {
17075 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17076 })
17077 }
17078
17079 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17080 where
17081 E: serde::de::Error,
17082 {
17083 i32::try_from(v)
17084 .ok()
17085 .and_then(|x| x.try_into().ok())
17086 .ok_or_else(|| {
17087 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17088 })
17089 }
17090
17091 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17092 where
17093 E: serde::de::Error,
17094 {
17095 match value {
17096 "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
17097 "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
17098 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17099 }
17100 }
17101 }
17102 deserializer.deserialize_any(GeneratedVisitor)
17103 }
17104}
17105impl serde::Serialize for VersionUpdatePayload {
17106 #[allow(deprecated)]
17107 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17108 where
17109 S: serde::Serializer,
17110 {
17111 use serde::ser::SerializeStruct;
17112 let mut len = 0;
17113 if self.payload.is_some() {
17114 len += 1;
17115 }
17116 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
17117 if let Some(v) = self.payload.as_ref() {
17118 match v {
17119 version_update_payload::Payload::VersionDeltas(v) => {
17120 struct_ser.serialize_field("versionDeltas", v)?;
17121 }
17122 version_update_payload::Payload::PinnedVersion(v) => {
17123 struct_ser.serialize_field("pinnedVersion", v)?;
17124 }
17125 }
17126 }
17127 struct_ser.end()
17128 }
17129}
17130impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
17131 #[allow(deprecated)]
17132 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17133 where
17134 D: serde::Deserializer<'de>,
17135 {
17136 const FIELDS: &[&str] = &[
17137 "version_deltas",
17138 "versionDeltas",
17139 "pinned_version",
17140 "pinnedVersion",
17141 ];
17142
17143 #[allow(clippy::enum_variant_names)]
17144 enum GeneratedField {
17145 VersionDeltas,
17146 PinnedVersion,
17147 }
17148 impl<'de> serde::Deserialize<'de> for GeneratedField {
17149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17150 where
17151 D: serde::Deserializer<'de>,
17152 {
17153 struct GeneratedVisitor;
17154
17155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17156 type Value = GeneratedField;
17157
17158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17159 write!(formatter, "expected one of: {:?}", &FIELDS)
17160 }
17161
17162 #[allow(unused_variables)]
17163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17164 where
17165 E: serde::de::Error,
17166 {
17167 match value {
17168 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
17169 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
17170 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17171 }
17172 }
17173 }
17174 deserializer.deserialize_identifier(GeneratedVisitor)
17175 }
17176 }
17177 struct GeneratedVisitor;
17178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17179 type Value = VersionUpdatePayload;
17180
17181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17182 formatter.write_str("struct hummock.VersionUpdatePayload")
17183 }
17184
17185 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
17186 where
17187 V: serde::de::MapAccess<'de>,
17188 {
17189 let mut payload__ = None;
17190 while let Some(k) = map_.next_key()? {
17191 match k {
17192 GeneratedField::VersionDeltas => {
17193 if payload__.is_some() {
17194 return Err(serde::de::Error::duplicate_field("versionDeltas"));
17195 }
17196 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
17197;
17198 }
17199 GeneratedField::PinnedVersion => {
17200 if payload__.is_some() {
17201 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
17202 }
17203 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
17204;
17205 }
17206 }
17207 }
17208 Ok(VersionUpdatePayload {
17209 payload: payload__,
17210 })
17211 }
17212 }
17213 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
17214 }
17215}
17216impl serde::Serialize for VnodeWatermark {
17217 #[allow(deprecated)]
17218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17219 where
17220 S: serde::Serializer,
17221 {
17222 use serde::ser::SerializeStruct;
17223 let mut len = 0;
17224 if !self.watermark.is_empty() {
17225 len += 1;
17226 }
17227 if self.vnode_bitmap.is_some() {
17228 len += 1;
17229 }
17230 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
17231 if !self.watermark.is_empty() {
17232 #[allow(clippy::needless_borrow)]
17233 #[allow(clippy::needless_borrows_for_generic_args)]
17234 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
17235 }
17236 if let Some(v) = self.vnode_bitmap.as_ref() {
17237 struct_ser.serialize_field("vnodeBitmap", v)?;
17238 }
17239 struct_ser.end()
17240 }
17241}
17242impl<'de> serde::Deserialize<'de> for VnodeWatermark {
17243 #[allow(deprecated)]
17244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17245 where
17246 D: serde::Deserializer<'de>,
17247 {
17248 const FIELDS: &[&str] = &[
17249 "watermark",
17250 "vnode_bitmap",
17251 "vnodeBitmap",
17252 ];
17253
17254 #[allow(clippy::enum_variant_names)]
17255 enum GeneratedField {
17256 Watermark,
17257 VnodeBitmap,
17258 }
17259 impl<'de> serde::Deserialize<'de> for GeneratedField {
17260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17261 where
17262 D: serde::Deserializer<'de>,
17263 {
17264 struct GeneratedVisitor;
17265
17266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17267 type Value = GeneratedField;
17268
17269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17270 write!(formatter, "expected one of: {:?}", &FIELDS)
17271 }
17272
17273 #[allow(unused_variables)]
17274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17275 where
17276 E: serde::de::Error,
17277 {
17278 match value {
17279 "watermark" => Ok(GeneratedField::Watermark),
17280 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
17281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17282 }
17283 }
17284 }
17285 deserializer.deserialize_identifier(GeneratedVisitor)
17286 }
17287 }
17288 struct GeneratedVisitor;
17289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17290 type Value = VnodeWatermark;
17291
17292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17293 formatter.write_str("struct hummock.VnodeWatermark")
17294 }
17295
17296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
17297 where
17298 V: serde::de::MapAccess<'de>,
17299 {
17300 let mut watermark__ = None;
17301 let mut vnode_bitmap__ = None;
17302 while let Some(k) = map_.next_key()? {
17303 match k {
17304 GeneratedField::Watermark => {
17305 if watermark__.is_some() {
17306 return Err(serde::de::Error::duplicate_field("watermark"));
17307 }
17308 watermark__ =
17309 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
17310 ;
17311 }
17312 GeneratedField::VnodeBitmap => {
17313 if vnode_bitmap__.is_some() {
17314 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
17315 }
17316 vnode_bitmap__ = map_.next_value()?;
17317 }
17318 }
17319 }
17320 Ok(VnodeWatermark {
17321 watermark: watermark__.unwrap_or_default(),
17322 vnode_bitmap: vnode_bitmap__,
17323 })
17324 }
17325 }
17326 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
17327 }
17328}
17329impl serde::Serialize for WriteLimits {
17330 #[allow(deprecated)]
17331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17332 where
17333 S: serde::Serializer,
17334 {
17335 use serde::ser::SerializeStruct;
17336 let mut len = 0;
17337 if !self.write_limits.is_empty() {
17338 len += 1;
17339 }
17340 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
17341 if !self.write_limits.is_empty() {
17342 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
17343 }
17344 struct_ser.end()
17345 }
17346}
17347impl<'de> serde::Deserialize<'de> for WriteLimits {
17348 #[allow(deprecated)]
17349 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17350 where
17351 D: serde::Deserializer<'de>,
17352 {
17353 const FIELDS: &[&str] = &[
17354 "write_limits",
17355 "writeLimits",
17356 ];
17357
17358 #[allow(clippy::enum_variant_names)]
17359 enum GeneratedField {
17360 WriteLimits,
17361 }
17362 impl<'de> serde::Deserialize<'de> for GeneratedField {
17363 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17364 where
17365 D: serde::Deserializer<'de>,
17366 {
17367 struct GeneratedVisitor;
17368
17369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17370 type Value = GeneratedField;
17371
17372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17373 write!(formatter, "expected one of: {:?}", &FIELDS)
17374 }
17375
17376 #[allow(unused_variables)]
17377 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17378 where
17379 E: serde::de::Error,
17380 {
17381 match value {
17382 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
17383 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17384 }
17385 }
17386 }
17387 deserializer.deserialize_identifier(GeneratedVisitor)
17388 }
17389 }
17390 struct GeneratedVisitor;
17391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17392 type Value = WriteLimits;
17393
17394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17395 formatter.write_str("struct hummock.WriteLimits")
17396 }
17397
17398 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
17399 where
17400 V: serde::de::MapAccess<'de>,
17401 {
17402 let mut write_limits__ = None;
17403 while let Some(k) = map_.next_key()? {
17404 match k {
17405 GeneratedField::WriteLimits => {
17406 if write_limits__.is_some() {
17407 return Err(serde::de::Error::duplicate_field("writeLimits"));
17408 }
17409 write_limits__ = Some(
17410 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
17411 .into_iter().map(|(k,v)| (k.0, v)).collect()
17412 );
17413 }
17414 }
17415 }
17416 Ok(WriteLimits {
17417 write_limits: write_limits__.unwrap_or_default(),
17418 })
17419 }
17420 }
17421 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
17422 }
17423}
17424impl serde::Serialize for write_limits::WriteLimit {
17425 #[allow(deprecated)]
17426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17427 where
17428 S: serde::Serializer,
17429 {
17430 use serde::ser::SerializeStruct;
17431 let mut len = 0;
17432 if !self.table_ids.is_empty() {
17433 len += 1;
17434 }
17435 if !self.reason.is_empty() {
17436 len += 1;
17437 }
17438 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
17439 if !self.table_ids.is_empty() {
17440 struct_ser.serialize_field("tableIds", &self.table_ids)?;
17441 }
17442 if !self.reason.is_empty() {
17443 struct_ser.serialize_field("reason", &self.reason)?;
17444 }
17445 struct_ser.end()
17446 }
17447}
17448impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
17449 #[allow(deprecated)]
17450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17451 where
17452 D: serde::Deserializer<'de>,
17453 {
17454 const FIELDS: &[&str] = &[
17455 "table_ids",
17456 "tableIds",
17457 "reason",
17458 ];
17459
17460 #[allow(clippy::enum_variant_names)]
17461 enum GeneratedField {
17462 TableIds,
17463 Reason,
17464 }
17465 impl<'de> serde::Deserialize<'de> for GeneratedField {
17466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17467 where
17468 D: serde::Deserializer<'de>,
17469 {
17470 struct GeneratedVisitor;
17471
17472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17473 type Value = GeneratedField;
17474
17475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17476 write!(formatter, "expected one of: {:?}", &FIELDS)
17477 }
17478
17479 #[allow(unused_variables)]
17480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17481 where
17482 E: serde::de::Error,
17483 {
17484 match value {
17485 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
17486 "reason" => Ok(GeneratedField::Reason),
17487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17488 }
17489 }
17490 }
17491 deserializer.deserialize_identifier(GeneratedVisitor)
17492 }
17493 }
17494 struct GeneratedVisitor;
17495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17496 type Value = write_limits::WriteLimit;
17497
17498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17499 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
17500 }
17501
17502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
17503 where
17504 V: serde::de::MapAccess<'de>,
17505 {
17506 let mut table_ids__ = None;
17507 let mut reason__ = None;
17508 while let Some(k) = map_.next_key()? {
17509 match k {
17510 GeneratedField::TableIds => {
17511 if table_ids__.is_some() {
17512 return Err(serde::de::Error::duplicate_field("tableIds"));
17513 }
17514 table_ids__ =
17515 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17516 .into_iter().map(|x| x.0).collect())
17517 ;
17518 }
17519 GeneratedField::Reason => {
17520 if reason__.is_some() {
17521 return Err(serde::de::Error::duplicate_field("reason"));
17522 }
17523 reason__ = Some(map_.next_value()?);
17524 }
17525 }
17526 }
17527 Ok(write_limits::WriteLimit {
17528 table_ids: table_ids__.unwrap_or_default(),
17529 reason: reason__.unwrap_or_default(),
17530 })
17531 }
17532 }
17533 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
17534 }
17535}