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 if self.next_vector_id != 0 {
3254 len += 1;
3255 }
3256 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3257 if let Some(v) = self.config.as_ref() {
3258 struct_ser.serialize_field("config", v)?;
3259 }
3260 if !self.vector_files.is_empty() {
3261 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3262 }
3263 if self.next_vector_id != 0 {
3264 #[allow(clippy::needless_borrow)]
3265 #[allow(clippy::needless_borrows_for_generic_args)]
3266 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3267 }
3268 struct_ser.end()
3269 }
3270}
3271impl<'de> serde::Deserialize<'de> for FlatIndex {
3272 #[allow(deprecated)]
3273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3274 where
3275 D: serde::Deserializer<'de>,
3276 {
3277 const FIELDS: &[&str] = &[
3278 "config",
3279 "vector_files",
3280 "vectorFiles",
3281 "next_vector_id",
3282 "nextVectorId",
3283 ];
3284
3285 #[allow(clippy::enum_variant_names)]
3286 enum GeneratedField {
3287 Config,
3288 VectorFiles,
3289 NextVectorId,
3290 }
3291 impl<'de> serde::Deserialize<'de> for GeneratedField {
3292 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3293 where
3294 D: serde::Deserializer<'de>,
3295 {
3296 struct GeneratedVisitor;
3297
3298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3299 type Value = GeneratedField;
3300
3301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3302 write!(formatter, "expected one of: {:?}", &FIELDS)
3303 }
3304
3305 #[allow(unused_variables)]
3306 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3307 where
3308 E: serde::de::Error,
3309 {
3310 match value {
3311 "config" => Ok(GeneratedField::Config),
3312 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3313 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3314 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3315 }
3316 }
3317 }
3318 deserializer.deserialize_identifier(GeneratedVisitor)
3319 }
3320 }
3321 struct GeneratedVisitor;
3322 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3323 type Value = FlatIndex;
3324
3325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3326 formatter.write_str("struct hummock.FlatIndex")
3327 }
3328
3329 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3330 where
3331 V: serde::de::MapAccess<'de>,
3332 {
3333 let mut config__ = None;
3334 let mut vector_files__ = None;
3335 let mut next_vector_id__ = None;
3336 while let Some(k) = map_.next_key()? {
3337 match k {
3338 GeneratedField::Config => {
3339 if config__.is_some() {
3340 return Err(serde::de::Error::duplicate_field("config"));
3341 }
3342 config__ = map_.next_value()?;
3343 }
3344 GeneratedField::VectorFiles => {
3345 if vector_files__.is_some() {
3346 return Err(serde::de::Error::duplicate_field("vectorFiles"));
3347 }
3348 vector_files__ = Some(map_.next_value()?);
3349 }
3350 GeneratedField::NextVectorId => {
3351 if next_vector_id__.is_some() {
3352 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3353 }
3354 next_vector_id__ =
3355 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3356 ;
3357 }
3358 }
3359 }
3360 Ok(FlatIndex {
3361 config: config__,
3362 vector_files: vector_files__.unwrap_or_default(),
3363 next_vector_id: next_vector_id__.unwrap_or_default(),
3364 })
3365 }
3366 }
3367 deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3368 }
3369}
3370impl serde::Serialize for FlatIndexAdd {
3371 #[allow(deprecated)]
3372 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3373 where
3374 S: serde::Serializer,
3375 {
3376 use serde::ser::SerializeStruct;
3377 let mut len = 0;
3378 if !self.added_vector_files.is_empty() {
3379 len += 1;
3380 }
3381 if self.next_vector_id != 0 {
3382 len += 1;
3383 }
3384 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3385 if !self.added_vector_files.is_empty() {
3386 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3387 }
3388 if self.next_vector_id != 0 {
3389 #[allow(clippy::needless_borrow)]
3390 #[allow(clippy::needless_borrows_for_generic_args)]
3391 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3392 }
3393 struct_ser.end()
3394 }
3395}
3396impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3397 #[allow(deprecated)]
3398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3399 where
3400 D: serde::Deserializer<'de>,
3401 {
3402 const FIELDS: &[&str] = &[
3403 "added_vector_files",
3404 "addedVectorFiles",
3405 "next_vector_id",
3406 "nextVectorId",
3407 ];
3408
3409 #[allow(clippy::enum_variant_names)]
3410 enum GeneratedField {
3411 AddedVectorFiles,
3412 NextVectorId,
3413 }
3414 impl<'de> serde::Deserialize<'de> for GeneratedField {
3415 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3416 where
3417 D: serde::Deserializer<'de>,
3418 {
3419 struct GeneratedVisitor;
3420
3421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3422 type Value = GeneratedField;
3423
3424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3425 write!(formatter, "expected one of: {:?}", &FIELDS)
3426 }
3427
3428 #[allow(unused_variables)]
3429 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3430 where
3431 E: serde::de::Error,
3432 {
3433 match value {
3434 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3435 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3437 }
3438 }
3439 }
3440 deserializer.deserialize_identifier(GeneratedVisitor)
3441 }
3442 }
3443 struct GeneratedVisitor;
3444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3445 type Value = FlatIndexAdd;
3446
3447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3448 formatter.write_str("struct hummock.FlatIndexAdd")
3449 }
3450
3451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3452 where
3453 V: serde::de::MapAccess<'de>,
3454 {
3455 let mut added_vector_files__ = None;
3456 let mut next_vector_id__ = None;
3457 while let Some(k) = map_.next_key()? {
3458 match k {
3459 GeneratedField::AddedVectorFiles => {
3460 if added_vector_files__.is_some() {
3461 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3462 }
3463 added_vector_files__ = Some(map_.next_value()?);
3464 }
3465 GeneratedField::NextVectorId => {
3466 if next_vector_id__.is_some() {
3467 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3468 }
3469 next_vector_id__ =
3470 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3471 ;
3472 }
3473 }
3474 }
3475 Ok(FlatIndexAdd {
3476 added_vector_files: added_vector_files__.unwrap_or_default(),
3477 next_vector_id: next_vector_id__.unwrap_or_default(),
3478 })
3479 }
3480 }
3481 deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3482 }
3483}
3484impl serde::Serialize for FlatIndexConfig {
3485 #[allow(deprecated)]
3486 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3487 where
3488 S: serde::Serializer,
3489 {
3490 use serde::ser::SerializeStruct;
3491 let len = 0;
3492 let struct_ser = serializer.serialize_struct("hummock.FlatIndexConfig", len)?;
3493 struct_ser.end()
3494 }
3495}
3496impl<'de> serde::Deserialize<'de> for FlatIndexConfig {
3497 #[allow(deprecated)]
3498 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3499 where
3500 D: serde::Deserializer<'de>,
3501 {
3502 const FIELDS: &[&str] = &[
3503 ];
3504
3505 #[allow(clippy::enum_variant_names)]
3506 enum GeneratedField {
3507 }
3508 impl<'de> serde::Deserialize<'de> for GeneratedField {
3509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3510 where
3511 D: serde::Deserializer<'de>,
3512 {
3513 struct GeneratedVisitor;
3514
3515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3516 type Value = GeneratedField;
3517
3518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3519 write!(formatter, "expected one of: {:?}", &FIELDS)
3520 }
3521
3522 #[allow(unused_variables)]
3523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3524 where
3525 E: serde::de::Error,
3526 {
3527 Err(serde::de::Error::unknown_field(value, FIELDS))
3528 }
3529 }
3530 deserializer.deserialize_identifier(GeneratedVisitor)
3531 }
3532 }
3533 struct GeneratedVisitor;
3534 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3535 type Value = FlatIndexConfig;
3536
3537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3538 formatter.write_str("struct hummock.FlatIndexConfig")
3539 }
3540
3541 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexConfig, V::Error>
3542 where
3543 V: serde::de::MapAccess<'de>,
3544 {
3545 while map_.next_key::<GeneratedField>()?.is_some() {
3546 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3547 }
3548 Ok(FlatIndexConfig {
3549 })
3550 }
3551 }
3552 deserializer.deserialize_struct("hummock.FlatIndexConfig", FIELDS, GeneratedVisitor)
3553 }
3554}
3555impl serde::Serialize for FullScanTask {
3556 #[allow(deprecated)]
3557 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3558 where
3559 S: serde::Serializer,
3560 {
3561 use serde::ser::SerializeStruct;
3562 let mut len = 0;
3563 if self.sst_retention_watermark != 0 {
3564 len += 1;
3565 }
3566 if self.prefix.is_some() {
3567 len += 1;
3568 }
3569 if self.start_after.is_some() {
3570 len += 1;
3571 }
3572 if self.limit.is_some() {
3573 len += 1;
3574 }
3575 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3576 if self.sst_retention_watermark != 0 {
3577 #[allow(clippy::needless_borrow)]
3578 #[allow(clippy::needless_borrows_for_generic_args)]
3579 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3580 }
3581 if let Some(v) = self.prefix.as_ref() {
3582 struct_ser.serialize_field("prefix", v)?;
3583 }
3584 if let Some(v) = self.start_after.as_ref() {
3585 struct_ser.serialize_field("startAfter", v)?;
3586 }
3587 if let Some(v) = self.limit.as_ref() {
3588 #[allow(clippy::needless_borrow)]
3589 #[allow(clippy::needless_borrows_for_generic_args)]
3590 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3591 }
3592 struct_ser.end()
3593 }
3594}
3595impl<'de> serde::Deserialize<'de> for FullScanTask {
3596 #[allow(deprecated)]
3597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3598 where
3599 D: serde::Deserializer<'de>,
3600 {
3601 const FIELDS: &[&str] = &[
3602 "sst_retention_watermark",
3603 "sstRetentionWatermark",
3604 "prefix",
3605 "start_after",
3606 "startAfter",
3607 "limit",
3608 ];
3609
3610 #[allow(clippy::enum_variant_names)]
3611 enum GeneratedField {
3612 SstRetentionWatermark,
3613 Prefix,
3614 StartAfter,
3615 Limit,
3616 }
3617 impl<'de> serde::Deserialize<'de> for GeneratedField {
3618 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3619 where
3620 D: serde::Deserializer<'de>,
3621 {
3622 struct GeneratedVisitor;
3623
3624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3625 type Value = GeneratedField;
3626
3627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3628 write!(formatter, "expected one of: {:?}", &FIELDS)
3629 }
3630
3631 #[allow(unused_variables)]
3632 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3633 where
3634 E: serde::de::Error,
3635 {
3636 match value {
3637 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3638 "prefix" => Ok(GeneratedField::Prefix),
3639 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3640 "limit" => Ok(GeneratedField::Limit),
3641 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3642 }
3643 }
3644 }
3645 deserializer.deserialize_identifier(GeneratedVisitor)
3646 }
3647 }
3648 struct GeneratedVisitor;
3649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3650 type Value = FullScanTask;
3651
3652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3653 formatter.write_str("struct hummock.FullScanTask")
3654 }
3655
3656 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3657 where
3658 V: serde::de::MapAccess<'de>,
3659 {
3660 let mut sst_retention_watermark__ = None;
3661 let mut prefix__ = None;
3662 let mut start_after__ = None;
3663 let mut limit__ = None;
3664 while let Some(k) = map_.next_key()? {
3665 match k {
3666 GeneratedField::SstRetentionWatermark => {
3667 if sst_retention_watermark__.is_some() {
3668 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3669 }
3670 sst_retention_watermark__ =
3671 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3672 ;
3673 }
3674 GeneratedField::Prefix => {
3675 if prefix__.is_some() {
3676 return Err(serde::de::Error::duplicate_field("prefix"));
3677 }
3678 prefix__ = map_.next_value()?;
3679 }
3680 GeneratedField::StartAfter => {
3681 if start_after__.is_some() {
3682 return Err(serde::de::Error::duplicate_field("startAfter"));
3683 }
3684 start_after__ = map_.next_value()?;
3685 }
3686 GeneratedField::Limit => {
3687 if limit__.is_some() {
3688 return Err(serde::de::Error::duplicate_field("limit"));
3689 }
3690 limit__ =
3691 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3692 ;
3693 }
3694 }
3695 }
3696 Ok(FullScanTask {
3697 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3698 prefix: prefix__,
3699 start_after: start_after__,
3700 limit: limit__,
3701 })
3702 }
3703 }
3704 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3705 }
3706}
3707impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3708 #[allow(deprecated)]
3709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3710 where
3711 S: serde::Serializer,
3712 {
3713 use serde::ser::SerializeStruct;
3714 let len = 0;
3715 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3716 struct_ser.end()
3717 }
3718}
3719impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3720 #[allow(deprecated)]
3721 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3722 where
3723 D: serde::Deserializer<'de>,
3724 {
3725 const FIELDS: &[&str] = &[
3726 ];
3727
3728 #[allow(clippy::enum_variant_names)]
3729 enum GeneratedField {
3730 }
3731 impl<'de> serde::Deserialize<'de> for GeneratedField {
3732 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3733 where
3734 D: serde::Deserializer<'de>,
3735 {
3736 struct GeneratedVisitor;
3737
3738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3739 type Value = GeneratedField;
3740
3741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3742 write!(formatter, "expected one of: {:?}", &FIELDS)
3743 }
3744
3745 #[allow(unused_variables)]
3746 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3747 where
3748 E: serde::de::Error,
3749 {
3750 Err(serde::de::Error::unknown_field(value, FIELDS))
3751 }
3752 }
3753 deserializer.deserialize_identifier(GeneratedVisitor)
3754 }
3755 }
3756 struct GeneratedVisitor;
3757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3758 type Value = GetAssignedCompactTaskNumRequest;
3759
3760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3761 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3762 }
3763
3764 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3765 where
3766 V: serde::de::MapAccess<'de>,
3767 {
3768 while map_.next_key::<GeneratedField>()?.is_some() {
3769 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3770 }
3771 Ok(GetAssignedCompactTaskNumRequest {
3772 })
3773 }
3774 }
3775 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3776 }
3777}
3778impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3779 #[allow(deprecated)]
3780 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3781 where
3782 S: serde::Serializer,
3783 {
3784 use serde::ser::SerializeStruct;
3785 let mut len = 0;
3786 if self.num_tasks != 0 {
3787 len += 1;
3788 }
3789 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3790 if self.num_tasks != 0 {
3791 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3792 }
3793 struct_ser.end()
3794 }
3795}
3796impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3797 #[allow(deprecated)]
3798 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3799 where
3800 D: serde::Deserializer<'de>,
3801 {
3802 const FIELDS: &[&str] = &[
3803 "num_tasks",
3804 "numTasks",
3805 ];
3806
3807 #[allow(clippy::enum_variant_names)]
3808 enum GeneratedField {
3809 NumTasks,
3810 }
3811 impl<'de> serde::Deserialize<'de> for GeneratedField {
3812 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3813 where
3814 D: serde::Deserializer<'de>,
3815 {
3816 struct GeneratedVisitor;
3817
3818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3819 type Value = GeneratedField;
3820
3821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3822 write!(formatter, "expected one of: {:?}", &FIELDS)
3823 }
3824
3825 #[allow(unused_variables)]
3826 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3827 where
3828 E: serde::de::Error,
3829 {
3830 match value {
3831 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3832 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3833 }
3834 }
3835 }
3836 deserializer.deserialize_identifier(GeneratedVisitor)
3837 }
3838 }
3839 struct GeneratedVisitor;
3840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3841 type Value = GetAssignedCompactTaskNumResponse;
3842
3843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3844 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3845 }
3846
3847 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3848 where
3849 V: serde::de::MapAccess<'de>,
3850 {
3851 let mut num_tasks__ = None;
3852 while let Some(k) = map_.next_key()? {
3853 match k {
3854 GeneratedField::NumTasks => {
3855 if num_tasks__.is_some() {
3856 return Err(serde::de::Error::duplicate_field("numTasks"));
3857 }
3858 num_tasks__ =
3859 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3860 ;
3861 }
3862 }
3863 }
3864 Ok(GetAssignedCompactTaskNumResponse {
3865 num_tasks: num_tasks__.unwrap_or_default(),
3866 })
3867 }
3868 }
3869 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3870 }
3871}
3872impl serde::Serialize for GetCompactionScoreRequest {
3873 #[allow(deprecated)]
3874 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3875 where
3876 S: serde::Serializer,
3877 {
3878 use serde::ser::SerializeStruct;
3879 let mut len = 0;
3880 if self.compaction_group_id != 0 {
3881 len += 1;
3882 }
3883 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3884 if self.compaction_group_id != 0 {
3885 #[allow(clippy::needless_borrow)]
3886 #[allow(clippy::needless_borrows_for_generic_args)]
3887 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3888 }
3889 struct_ser.end()
3890 }
3891}
3892impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3893 #[allow(deprecated)]
3894 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3895 where
3896 D: serde::Deserializer<'de>,
3897 {
3898 const FIELDS: &[&str] = &[
3899 "compaction_group_id",
3900 "compactionGroupId",
3901 ];
3902
3903 #[allow(clippy::enum_variant_names)]
3904 enum GeneratedField {
3905 CompactionGroupId,
3906 }
3907 impl<'de> serde::Deserialize<'de> for GeneratedField {
3908 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3909 where
3910 D: serde::Deserializer<'de>,
3911 {
3912 struct GeneratedVisitor;
3913
3914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3915 type Value = GeneratedField;
3916
3917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3918 write!(formatter, "expected one of: {:?}", &FIELDS)
3919 }
3920
3921 #[allow(unused_variables)]
3922 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3923 where
3924 E: serde::de::Error,
3925 {
3926 match value {
3927 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3928 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3929 }
3930 }
3931 }
3932 deserializer.deserialize_identifier(GeneratedVisitor)
3933 }
3934 }
3935 struct GeneratedVisitor;
3936 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3937 type Value = GetCompactionScoreRequest;
3938
3939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3940 formatter.write_str("struct hummock.GetCompactionScoreRequest")
3941 }
3942
3943 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3944 where
3945 V: serde::de::MapAccess<'de>,
3946 {
3947 let mut compaction_group_id__ = None;
3948 while let Some(k) = map_.next_key()? {
3949 match k {
3950 GeneratedField::CompactionGroupId => {
3951 if compaction_group_id__.is_some() {
3952 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3953 }
3954 compaction_group_id__ =
3955 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3956 ;
3957 }
3958 }
3959 }
3960 Ok(GetCompactionScoreRequest {
3961 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3962 })
3963 }
3964 }
3965 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
3966 }
3967}
3968impl serde::Serialize for GetCompactionScoreResponse {
3969 #[allow(deprecated)]
3970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3971 where
3972 S: serde::Serializer,
3973 {
3974 use serde::ser::SerializeStruct;
3975 let mut len = 0;
3976 if self.compaction_group_id != 0 {
3977 len += 1;
3978 }
3979 if !self.scores.is_empty() {
3980 len += 1;
3981 }
3982 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
3983 if self.compaction_group_id != 0 {
3984 #[allow(clippy::needless_borrow)]
3985 #[allow(clippy::needless_borrows_for_generic_args)]
3986 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3987 }
3988 if !self.scores.is_empty() {
3989 struct_ser.serialize_field("scores", &self.scores)?;
3990 }
3991 struct_ser.end()
3992 }
3993}
3994impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
3995 #[allow(deprecated)]
3996 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3997 where
3998 D: serde::Deserializer<'de>,
3999 {
4000 const FIELDS: &[&str] = &[
4001 "compaction_group_id",
4002 "compactionGroupId",
4003 "scores",
4004 ];
4005
4006 #[allow(clippy::enum_variant_names)]
4007 enum GeneratedField {
4008 CompactionGroupId,
4009 Scores,
4010 }
4011 impl<'de> serde::Deserialize<'de> for GeneratedField {
4012 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4013 where
4014 D: serde::Deserializer<'de>,
4015 {
4016 struct GeneratedVisitor;
4017
4018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4019 type Value = GeneratedField;
4020
4021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4022 write!(formatter, "expected one of: {:?}", &FIELDS)
4023 }
4024
4025 #[allow(unused_variables)]
4026 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4027 where
4028 E: serde::de::Error,
4029 {
4030 match value {
4031 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
4032 "scores" => Ok(GeneratedField::Scores),
4033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4034 }
4035 }
4036 }
4037 deserializer.deserialize_identifier(GeneratedVisitor)
4038 }
4039 }
4040 struct GeneratedVisitor;
4041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4042 type Value = GetCompactionScoreResponse;
4043
4044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4045 formatter.write_str("struct hummock.GetCompactionScoreResponse")
4046 }
4047
4048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
4049 where
4050 V: serde::de::MapAccess<'de>,
4051 {
4052 let mut compaction_group_id__ = None;
4053 let mut scores__ = None;
4054 while let Some(k) = map_.next_key()? {
4055 match k {
4056 GeneratedField::CompactionGroupId => {
4057 if compaction_group_id__.is_some() {
4058 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
4059 }
4060 compaction_group_id__ =
4061 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4062 ;
4063 }
4064 GeneratedField::Scores => {
4065 if scores__.is_some() {
4066 return Err(serde::de::Error::duplicate_field("scores"));
4067 }
4068 scores__ = Some(map_.next_value()?);
4069 }
4070 }
4071 }
4072 Ok(GetCompactionScoreResponse {
4073 compaction_group_id: compaction_group_id__.unwrap_or_default(),
4074 scores: scores__.unwrap_or_default(),
4075 })
4076 }
4077 }
4078 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
4079 }
4080}
4081impl serde::Serialize for get_compaction_score_response::PickerInfo {
4082 #[allow(deprecated)]
4083 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4084 where
4085 S: serde::Serializer,
4086 {
4087 use serde::ser::SerializeStruct;
4088 let mut len = 0;
4089 if self.score != 0 {
4090 len += 1;
4091 }
4092 if self.select_level != 0 {
4093 len += 1;
4094 }
4095 if self.target_level != 0 {
4096 len += 1;
4097 }
4098 if !self.picker_type.is_empty() {
4099 len += 1;
4100 }
4101 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
4102 if self.score != 0 {
4103 #[allow(clippy::needless_borrow)]
4104 #[allow(clippy::needless_borrows_for_generic_args)]
4105 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
4106 }
4107 if self.select_level != 0 {
4108 #[allow(clippy::needless_borrow)]
4109 #[allow(clippy::needless_borrows_for_generic_args)]
4110 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
4111 }
4112 if self.target_level != 0 {
4113 #[allow(clippy::needless_borrow)]
4114 #[allow(clippy::needless_borrows_for_generic_args)]
4115 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
4116 }
4117 if !self.picker_type.is_empty() {
4118 struct_ser.serialize_field("pickerType", &self.picker_type)?;
4119 }
4120 struct_ser.end()
4121 }
4122}
4123impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
4124 #[allow(deprecated)]
4125 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4126 where
4127 D: serde::Deserializer<'de>,
4128 {
4129 const FIELDS: &[&str] = &[
4130 "score",
4131 "select_level",
4132 "selectLevel",
4133 "target_level",
4134 "targetLevel",
4135 "picker_type",
4136 "pickerType",
4137 ];
4138
4139 #[allow(clippy::enum_variant_names)]
4140 enum GeneratedField {
4141 Score,
4142 SelectLevel,
4143 TargetLevel,
4144 PickerType,
4145 }
4146 impl<'de> serde::Deserialize<'de> for GeneratedField {
4147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4148 where
4149 D: serde::Deserializer<'de>,
4150 {
4151 struct GeneratedVisitor;
4152
4153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4154 type Value = GeneratedField;
4155
4156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4157 write!(formatter, "expected one of: {:?}", &FIELDS)
4158 }
4159
4160 #[allow(unused_variables)]
4161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4162 where
4163 E: serde::de::Error,
4164 {
4165 match value {
4166 "score" => Ok(GeneratedField::Score),
4167 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4168 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4169 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4170 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4171 }
4172 }
4173 }
4174 deserializer.deserialize_identifier(GeneratedVisitor)
4175 }
4176 }
4177 struct GeneratedVisitor;
4178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4179 type Value = get_compaction_score_response::PickerInfo;
4180
4181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4182 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4183 }
4184
4185 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4186 where
4187 V: serde::de::MapAccess<'de>,
4188 {
4189 let mut score__ = None;
4190 let mut select_level__ = None;
4191 let mut target_level__ = None;
4192 let mut picker_type__ = None;
4193 while let Some(k) = map_.next_key()? {
4194 match k {
4195 GeneratedField::Score => {
4196 if score__.is_some() {
4197 return Err(serde::de::Error::duplicate_field("score"));
4198 }
4199 score__ =
4200 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4201 ;
4202 }
4203 GeneratedField::SelectLevel => {
4204 if select_level__.is_some() {
4205 return Err(serde::de::Error::duplicate_field("selectLevel"));
4206 }
4207 select_level__ =
4208 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4209 ;
4210 }
4211 GeneratedField::TargetLevel => {
4212 if target_level__.is_some() {
4213 return Err(serde::de::Error::duplicate_field("targetLevel"));
4214 }
4215 target_level__ =
4216 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4217 ;
4218 }
4219 GeneratedField::PickerType => {
4220 if picker_type__.is_some() {
4221 return Err(serde::de::Error::duplicate_field("pickerType"));
4222 }
4223 picker_type__ = Some(map_.next_value()?);
4224 }
4225 }
4226 }
4227 Ok(get_compaction_score_response::PickerInfo {
4228 score: score__.unwrap_or_default(),
4229 select_level: select_level__.unwrap_or_default(),
4230 target_level: target_level__.unwrap_or_default(),
4231 picker_type: picker_type__.unwrap_or_default(),
4232 })
4233 }
4234 }
4235 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4236 }
4237}
4238impl serde::Serialize for GetCurrentVersionRequest {
4239 #[allow(deprecated)]
4240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4241 where
4242 S: serde::Serializer,
4243 {
4244 use serde::ser::SerializeStruct;
4245 let len = 0;
4246 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4247 struct_ser.end()
4248 }
4249}
4250impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4251 #[allow(deprecated)]
4252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4253 where
4254 D: serde::Deserializer<'de>,
4255 {
4256 const FIELDS: &[&str] = &[
4257 ];
4258
4259 #[allow(clippy::enum_variant_names)]
4260 enum GeneratedField {
4261 }
4262 impl<'de> serde::Deserialize<'de> for GeneratedField {
4263 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4264 where
4265 D: serde::Deserializer<'de>,
4266 {
4267 struct GeneratedVisitor;
4268
4269 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4270 type Value = GeneratedField;
4271
4272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4273 write!(formatter, "expected one of: {:?}", &FIELDS)
4274 }
4275
4276 #[allow(unused_variables)]
4277 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4278 where
4279 E: serde::de::Error,
4280 {
4281 Err(serde::de::Error::unknown_field(value, FIELDS))
4282 }
4283 }
4284 deserializer.deserialize_identifier(GeneratedVisitor)
4285 }
4286 }
4287 struct GeneratedVisitor;
4288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4289 type Value = GetCurrentVersionRequest;
4290
4291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4292 formatter.write_str("struct hummock.GetCurrentVersionRequest")
4293 }
4294
4295 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4296 where
4297 V: serde::de::MapAccess<'de>,
4298 {
4299 while map_.next_key::<GeneratedField>()?.is_some() {
4300 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4301 }
4302 Ok(GetCurrentVersionRequest {
4303 })
4304 }
4305 }
4306 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4307 }
4308}
4309impl serde::Serialize for GetCurrentVersionResponse {
4310 #[allow(deprecated)]
4311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4312 where
4313 S: serde::Serializer,
4314 {
4315 use serde::ser::SerializeStruct;
4316 let mut len = 0;
4317 if self.status.is_some() {
4318 len += 1;
4319 }
4320 if self.current_version.is_some() {
4321 len += 1;
4322 }
4323 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4324 if let Some(v) = self.status.as_ref() {
4325 struct_ser.serialize_field("status", v)?;
4326 }
4327 if let Some(v) = self.current_version.as_ref() {
4328 struct_ser.serialize_field("currentVersion", v)?;
4329 }
4330 struct_ser.end()
4331 }
4332}
4333impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4334 #[allow(deprecated)]
4335 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4336 where
4337 D: serde::Deserializer<'de>,
4338 {
4339 const FIELDS: &[&str] = &[
4340 "status",
4341 "current_version",
4342 "currentVersion",
4343 ];
4344
4345 #[allow(clippy::enum_variant_names)]
4346 enum GeneratedField {
4347 Status,
4348 CurrentVersion,
4349 }
4350 impl<'de> serde::Deserialize<'de> for GeneratedField {
4351 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4352 where
4353 D: serde::Deserializer<'de>,
4354 {
4355 struct GeneratedVisitor;
4356
4357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4358 type Value = GeneratedField;
4359
4360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4361 write!(formatter, "expected one of: {:?}", &FIELDS)
4362 }
4363
4364 #[allow(unused_variables)]
4365 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4366 where
4367 E: serde::de::Error,
4368 {
4369 match value {
4370 "status" => Ok(GeneratedField::Status),
4371 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4373 }
4374 }
4375 }
4376 deserializer.deserialize_identifier(GeneratedVisitor)
4377 }
4378 }
4379 struct GeneratedVisitor;
4380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4381 type Value = GetCurrentVersionResponse;
4382
4383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4384 formatter.write_str("struct hummock.GetCurrentVersionResponse")
4385 }
4386
4387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4388 where
4389 V: serde::de::MapAccess<'de>,
4390 {
4391 let mut status__ = None;
4392 let mut current_version__ = None;
4393 while let Some(k) = map_.next_key()? {
4394 match k {
4395 GeneratedField::Status => {
4396 if status__.is_some() {
4397 return Err(serde::de::Error::duplicate_field("status"));
4398 }
4399 status__ = map_.next_value()?;
4400 }
4401 GeneratedField::CurrentVersion => {
4402 if current_version__.is_some() {
4403 return Err(serde::de::Error::duplicate_field("currentVersion"));
4404 }
4405 current_version__ = map_.next_value()?;
4406 }
4407 }
4408 }
4409 Ok(GetCurrentVersionResponse {
4410 status: status__,
4411 current_version: current_version__,
4412 })
4413 }
4414 }
4415 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4416 }
4417}
4418impl serde::Serialize for GetNewObjectIdsRequest {
4419 #[allow(deprecated)]
4420 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4421 where
4422 S: serde::Serializer,
4423 {
4424 use serde::ser::SerializeStruct;
4425 let mut len = 0;
4426 if self.number != 0 {
4427 len += 1;
4428 }
4429 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4430 if self.number != 0 {
4431 struct_ser.serialize_field("number", &self.number)?;
4432 }
4433 struct_ser.end()
4434 }
4435}
4436impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4437 #[allow(deprecated)]
4438 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4439 where
4440 D: serde::Deserializer<'de>,
4441 {
4442 const FIELDS: &[&str] = &[
4443 "number",
4444 ];
4445
4446 #[allow(clippy::enum_variant_names)]
4447 enum GeneratedField {
4448 Number,
4449 }
4450 impl<'de> serde::Deserialize<'de> for GeneratedField {
4451 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4452 where
4453 D: serde::Deserializer<'de>,
4454 {
4455 struct GeneratedVisitor;
4456
4457 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4458 type Value = GeneratedField;
4459
4460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4461 write!(formatter, "expected one of: {:?}", &FIELDS)
4462 }
4463
4464 #[allow(unused_variables)]
4465 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4466 where
4467 E: serde::de::Error,
4468 {
4469 match value {
4470 "number" => Ok(GeneratedField::Number),
4471 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4472 }
4473 }
4474 }
4475 deserializer.deserialize_identifier(GeneratedVisitor)
4476 }
4477 }
4478 struct GeneratedVisitor;
4479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4480 type Value = GetNewObjectIdsRequest;
4481
4482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4483 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4484 }
4485
4486 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4487 where
4488 V: serde::de::MapAccess<'de>,
4489 {
4490 let mut number__ = None;
4491 while let Some(k) = map_.next_key()? {
4492 match k {
4493 GeneratedField::Number => {
4494 if number__.is_some() {
4495 return Err(serde::de::Error::duplicate_field("number"));
4496 }
4497 number__ =
4498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4499 ;
4500 }
4501 }
4502 }
4503 Ok(GetNewObjectIdsRequest {
4504 number: number__.unwrap_or_default(),
4505 })
4506 }
4507 }
4508 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4509 }
4510}
4511impl serde::Serialize for GetNewObjectIdsResponse {
4512 #[allow(deprecated)]
4513 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4514 where
4515 S: serde::Serializer,
4516 {
4517 use serde::ser::SerializeStruct;
4518 let mut len = 0;
4519 if self.status.is_some() {
4520 len += 1;
4521 }
4522 if self.start_id != 0 {
4523 len += 1;
4524 }
4525 if self.end_id != 0 {
4526 len += 1;
4527 }
4528 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4529 if let Some(v) = self.status.as_ref() {
4530 struct_ser.serialize_field("status", v)?;
4531 }
4532 if self.start_id != 0 {
4533 #[allow(clippy::needless_borrow)]
4534 #[allow(clippy::needless_borrows_for_generic_args)]
4535 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4536 }
4537 if self.end_id != 0 {
4538 #[allow(clippy::needless_borrow)]
4539 #[allow(clippy::needless_borrows_for_generic_args)]
4540 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4541 }
4542 struct_ser.end()
4543 }
4544}
4545impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4546 #[allow(deprecated)]
4547 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4548 where
4549 D: serde::Deserializer<'de>,
4550 {
4551 const FIELDS: &[&str] = &[
4552 "status",
4553 "start_id",
4554 "startId",
4555 "end_id",
4556 "endId",
4557 ];
4558
4559 #[allow(clippy::enum_variant_names)]
4560 enum GeneratedField {
4561 Status,
4562 StartId,
4563 EndId,
4564 }
4565 impl<'de> serde::Deserialize<'de> for GeneratedField {
4566 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4567 where
4568 D: serde::Deserializer<'de>,
4569 {
4570 struct GeneratedVisitor;
4571
4572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4573 type Value = GeneratedField;
4574
4575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4576 write!(formatter, "expected one of: {:?}", &FIELDS)
4577 }
4578
4579 #[allow(unused_variables)]
4580 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4581 where
4582 E: serde::de::Error,
4583 {
4584 match value {
4585 "status" => Ok(GeneratedField::Status),
4586 "startId" | "start_id" => Ok(GeneratedField::StartId),
4587 "endId" | "end_id" => Ok(GeneratedField::EndId),
4588 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4589 }
4590 }
4591 }
4592 deserializer.deserialize_identifier(GeneratedVisitor)
4593 }
4594 }
4595 struct GeneratedVisitor;
4596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4597 type Value = GetNewObjectIdsResponse;
4598
4599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4600 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4601 }
4602
4603 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4604 where
4605 V: serde::de::MapAccess<'de>,
4606 {
4607 let mut status__ = None;
4608 let mut start_id__ = None;
4609 let mut end_id__ = None;
4610 while let Some(k) = map_.next_key()? {
4611 match k {
4612 GeneratedField::Status => {
4613 if status__.is_some() {
4614 return Err(serde::de::Error::duplicate_field("status"));
4615 }
4616 status__ = map_.next_value()?;
4617 }
4618 GeneratedField::StartId => {
4619 if start_id__.is_some() {
4620 return Err(serde::de::Error::duplicate_field("startId"));
4621 }
4622 start_id__ =
4623 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4624 ;
4625 }
4626 GeneratedField::EndId => {
4627 if end_id__.is_some() {
4628 return Err(serde::de::Error::duplicate_field("endId"));
4629 }
4630 end_id__ =
4631 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4632 ;
4633 }
4634 }
4635 }
4636 Ok(GetNewObjectIdsResponse {
4637 status: status__,
4638 start_id: start_id__.unwrap_or_default(),
4639 end_id: end_id__.unwrap_or_default(),
4640 })
4641 }
4642 }
4643 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4644 }
4645}
4646impl serde::Serialize for GetVersionByEpochRequest {
4647 #[allow(deprecated)]
4648 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4649 where
4650 S: serde::Serializer,
4651 {
4652 use serde::ser::SerializeStruct;
4653 let mut len = 0;
4654 if self.epoch != 0 {
4655 len += 1;
4656 }
4657 if self.table_id != 0 {
4658 len += 1;
4659 }
4660 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
4661 if self.epoch != 0 {
4662 #[allow(clippy::needless_borrow)]
4663 #[allow(clippy::needless_borrows_for_generic_args)]
4664 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
4665 }
4666 if self.table_id != 0 {
4667 struct_ser.serialize_field("tableId", &self.table_id)?;
4668 }
4669 struct_ser.end()
4670 }
4671}
4672impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
4673 #[allow(deprecated)]
4674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4675 where
4676 D: serde::Deserializer<'de>,
4677 {
4678 const FIELDS: &[&str] = &[
4679 "epoch",
4680 "table_id",
4681 "tableId",
4682 ];
4683
4684 #[allow(clippy::enum_variant_names)]
4685 enum GeneratedField {
4686 Epoch,
4687 TableId,
4688 }
4689 impl<'de> serde::Deserialize<'de> for GeneratedField {
4690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4691 where
4692 D: serde::Deserializer<'de>,
4693 {
4694 struct GeneratedVisitor;
4695
4696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4697 type Value = GeneratedField;
4698
4699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4700 write!(formatter, "expected one of: {:?}", &FIELDS)
4701 }
4702
4703 #[allow(unused_variables)]
4704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4705 where
4706 E: serde::de::Error,
4707 {
4708 match value {
4709 "epoch" => Ok(GeneratedField::Epoch),
4710 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4712 }
4713 }
4714 }
4715 deserializer.deserialize_identifier(GeneratedVisitor)
4716 }
4717 }
4718 struct GeneratedVisitor;
4719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4720 type Value = GetVersionByEpochRequest;
4721
4722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4723 formatter.write_str("struct hummock.GetVersionByEpochRequest")
4724 }
4725
4726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
4727 where
4728 V: serde::de::MapAccess<'de>,
4729 {
4730 let mut epoch__ = None;
4731 let mut table_id__ = None;
4732 while let Some(k) = map_.next_key()? {
4733 match k {
4734 GeneratedField::Epoch => {
4735 if epoch__.is_some() {
4736 return Err(serde::de::Error::duplicate_field("epoch"));
4737 }
4738 epoch__ =
4739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4740 ;
4741 }
4742 GeneratedField::TableId => {
4743 if table_id__.is_some() {
4744 return Err(serde::de::Error::duplicate_field("tableId"));
4745 }
4746 table_id__ =
4747 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4748 ;
4749 }
4750 }
4751 }
4752 Ok(GetVersionByEpochRequest {
4753 epoch: epoch__.unwrap_or_default(),
4754 table_id: table_id__.unwrap_or_default(),
4755 })
4756 }
4757 }
4758 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
4759 }
4760}
4761impl serde::Serialize for GetVersionByEpochResponse {
4762 #[allow(deprecated)]
4763 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4764 where
4765 S: serde::Serializer,
4766 {
4767 use serde::ser::SerializeStruct;
4768 let mut len = 0;
4769 if self.version.is_some() {
4770 len += 1;
4771 }
4772 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
4773 if let Some(v) = self.version.as_ref() {
4774 struct_ser.serialize_field("version", v)?;
4775 }
4776 struct_ser.end()
4777 }
4778}
4779impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
4780 #[allow(deprecated)]
4781 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4782 where
4783 D: serde::Deserializer<'de>,
4784 {
4785 const FIELDS: &[&str] = &[
4786 "version",
4787 ];
4788
4789 #[allow(clippy::enum_variant_names)]
4790 enum GeneratedField {
4791 Version,
4792 }
4793 impl<'de> serde::Deserialize<'de> for GeneratedField {
4794 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4795 where
4796 D: serde::Deserializer<'de>,
4797 {
4798 struct GeneratedVisitor;
4799
4800 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4801 type Value = GeneratedField;
4802
4803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4804 write!(formatter, "expected one of: {:?}", &FIELDS)
4805 }
4806
4807 #[allow(unused_variables)]
4808 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4809 where
4810 E: serde::de::Error,
4811 {
4812 match value {
4813 "version" => Ok(GeneratedField::Version),
4814 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4815 }
4816 }
4817 }
4818 deserializer.deserialize_identifier(GeneratedVisitor)
4819 }
4820 }
4821 struct GeneratedVisitor;
4822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4823 type Value = GetVersionByEpochResponse;
4824
4825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4826 formatter.write_str("struct hummock.GetVersionByEpochResponse")
4827 }
4828
4829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
4830 where
4831 V: serde::de::MapAccess<'de>,
4832 {
4833 let mut version__ = None;
4834 while let Some(k) = map_.next_key()? {
4835 match k {
4836 GeneratedField::Version => {
4837 if version__.is_some() {
4838 return Err(serde::de::Error::duplicate_field("version"));
4839 }
4840 version__ = map_.next_value()?;
4841 }
4842 }
4843 }
4844 Ok(GetVersionByEpochResponse {
4845 version: version__,
4846 })
4847 }
4848 }
4849 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
4850 }
4851}
4852impl serde::Serialize for GroupConstruct {
4853 #[allow(deprecated)]
4854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4855 where
4856 S: serde::Serializer,
4857 {
4858 use serde::ser::SerializeStruct;
4859 let mut len = 0;
4860 if self.group_config.is_some() {
4861 len += 1;
4862 }
4863 if self.parent_group_id != 0 {
4864 len += 1;
4865 }
4866 if !self.table_ids.is_empty() {
4867 len += 1;
4868 }
4869 if self.group_id != 0 {
4870 len += 1;
4871 }
4872 if self.new_sst_start_id != 0 {
4873 len += 1;
4874 }
4875 if self.version != 0 {
4876 len += 1;
4877 }
4878 if self.split_key.is_some() {
4879 len += 1;
4880 }
4881 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
4882 if let Some(v) = self.group_config.as_ref() {
4883 struct_ser.serialize_field("groupConfig", v)?;
4884 }
4885 if self.parent_group_id != 0 {
4886 #[allow(clippy::needless_borrow)]
4887 #[allow(clippy::needless_borrows_for_generic_args)]
4888 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
4889 }
4890 if !self.table_ids.is_empty() {
4891 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4892 }
4893 if self.group_id != 0 {
4894 #[allow(clippy::needless_borrow)]
4895 #[allow(clippy::needless_borrows_for_generic_args)]
4896 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
4897 }
4898 if self.new_sst_start_id != 0 {
4899 #[allow(clippy::needless_borrow)]
4900 #[allow(clippy::needless_borrows_for_generic_args)]
4901 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
4902 }
4903 if self.version != 0 {
4904 let v = CompatibilityVersion::try_from(self.version)
4905 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4906 struct_ser.serialize_field("version", &v)?;
4907 }
4908 if let Some(v) = self.split_key.as_ref() {
4909 #[allow(clippy::needless_borrow)]
4910 #[allow(clippy::needless_borrows_for_generic_args)]
4911 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
4912 }
4913 struct_ser.end()
4914 }
4915}
4916impl<'de> serde::Deserialize<'de> for GroupConstruct {
4917 #[allow(deprecated)]
4918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4919 where
4920 D: serde::Deserializer<'de>,
4921 {
4922 const FIELDS: &[&str] = &[
4923 "group_config",
4924 "groupConfig",
4925 "parent_group_id",
4926 "parentGroupId",
4927 "table_ids",
4928 "tableIds",
4929 "group_id",
4930 "groupId",
4931 "new_sst_start_id",
4932 "newSstStartId",
4933 "version",
4934 "split_key",
4935 "splitKey",
4936 ];
4937
4938 #[allow(clippy::enum_variant_names)]
4939 enum GeneratedField {
4940 GroupConfig,
4941 ParentGroupId,
4942 TableIds,
4943 GroupId,
4944 NewSstStartId,
4945 Version,
4946 SplitKey,
4947 }
4948 impl<'de> serde::Deserialize<'de> for GeneratedField {
4949 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4950 where
4951 D: serde::Deserializer<'de>,
4952 {
4953 struct GeneratedVisitor;
4954
4955 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4956 type Value = GeneratedField;
4957
4958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4959 write!(formatter, "expected one of: {:?}", &FIELDS)
4960 }
4961
4962 #[allow(unused_variables)]
4963 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4964 where
4965 E: serde::de::Error,
4966 {
4967 match value {
4968 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
4969 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
4970 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4971 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
4972 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
4973 "version" => Ok(GeneratedField::Version),
4974 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
4975 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4976 }
4977 }
4978 }
4979 deserializer.deserialize_identifier(GeneratedVisitor)
4980 }
4981 }
4982 struct GeneratedVisitor;
4983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4984 type Value = GroupConstruct;
4985
4986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4987 formatter.write_str("struct hummock.GroupConstruct")
4988 }
4989
4990 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
4991 where
4992 V: serde::de::MapAccess<'de>,
4993 {
4994 let mut group_config__ = None;
4995 let mut parent_group_id__ = None;
4996 let mut table_ids__ = None;
4997 let mut group_id__ = None;
4998 let mut new_sst_start_id__ = None;
4999 let mut version__ = None;
5000 let mut split_key__ = None;
5001 while let Some(k) = map_.next_key()? {
5002 match k {
5003 GeneratedField::GroupConfig => {
5004 if group_config__.is_some() {
5005 return Err(serde::de::Error::duplicate_field("groupConfig"));
5006 }
5007 group_config__ = map_.next_value()?;
5008 }
5009 GeneratedField::ParentGroupId => {
5010 if parent_group_id__.is_some() {
5011 return Err(serde::de::Error::duplicate_field("parentGroupId"));
5012 }
5013 parent_group_id__ =
5014 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5015 ;
5016 }
5017 GeneratedField::TableIds => {
5018 if table_ids__.is_some() {
5019 return Err(serde::de::Error::duplicate_field("tableIds"));
5020 }
5021 table_ids__ =
5022 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5023 .into_iter().map(|x| x.0).collect())
5024 ;
5025 }
5026 GeneratedField::GroupId => {
5027 if group_id__.is_some() {
5028 return Err(serde::de::Error::duplicate_field("groupId"));
5029 }
5030 group_id__ =
5031 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5032 ;
5033 }
5034 GeneratedField::NewSstStartId => {
5035 if new_sst_start_id__.is_some() {
5036 return Err(serde::de::Error::duplicate_field("newSstStartId"));
5037 }
5038 new_sst_start_id__ =
5039 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5040 ;
5041 }
5042 GeneratedField::Version => {
5043 if version__.is_some() {
5044 return Err(serde::de::Error::duplicate_field("version"));
5045 }
5046 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
5047 }
5048 GeneratedField::SplitKey => {
5049 if split_key__.is_some() {
5050 return Err(serde::de::Error::duplicate_field("splitKey"));
5051 }
5052 split_key__ =
5053 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
5054 ;
5055 }
5056 }
5057 }
5058 Ok(GroupConstruct {
5059 group_config: group_config__,
5060 parent_group_id: parent_group_id__.unwrap_or_default(),
5061 table_ids: table_ids__.unwrap_or_default(),
5062 group_id: group_id__.unwrap_or_default(),
5063 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
5064 version: version__.unwrap_or_default(),
5065 split_key: split_key__,
5066 })
5067 }
5068 }
5069 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
5070 }
5071}
5072impl serde::Serialize for GroupDelta {
5073 #[allow(deprecated)]
5074 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5075 where
5076 S: serde::Serializer,
5077 {
5078 use serde::ser::SerializeStruct;
5079 let mut len = 0;
5080 if self.delta_type.is_some() {
5081 len += 1;
5082 }
5083 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
5084 if let Some(v) = self.delta_type.as_ref() {
5085 match v {
5086 group_delta::DeltaType::IntraLevel(v) => {
5087 struct_ser.serialize_field("intraLevel", v)?;
5088 }
5089 group_delta::DeltaType::GroupConstruct(v) => {
5090 struct_ser.serialize_field("groupConstruct", v)?;
5091 }
5092 group_delta::DeltaType::GroupDestroy(v) => {
5093 struct_ser.serialize_field("groupDestroy", v)?;
5094 }
5095 group_delta::DeltaType::GroupMerge(v) => {
5096 struct_ser.serialize_field("groupMerge", v)?;
5097 }
5098 group_delta::DeltaType::NewL0SubLevel(v) => {
5099 struct_ser.serialize_field("newL0SubLevel", v)?;
5100 }
5101 }
5102 }
5103 struct_ser.end()
5104 }
5105}
5106impl<'de> serde::Deserialize<'de> for GroupDelta {
5107 #[allow(deprecated)]
5108 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5109 where
5110 D: serde::Deserializer<'de>,
5111 {
5112 const FIELDS: &[&str] = &[
5113 "intra_level",
5114 "intraLevel",
5115 "group_construct",
5116 "groupConstruct",
5117 "group_destroy",
5118 "groupDestroy",
5119 "group_merge",
5120 "groupMerge",
5121 "new_l0_sub_level",
5122 "newL0SubLevel",
5123 ];
5124
5125 #[allow(clippy::enum_variant_names)]
5126 enum GeneratedField {
5127 IntraLevel,
5128 GroupConstruct,
5129 GroupDestroy,
5130 GroupMerge,
5131 NewL0SubLevel,
5132 }
5133 impl<'de> serde::Deserialize<'de> for GeneratedField {
5134 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5135 where
5136 D: serde::Deserializer<'de>,
5137 {
5138 struct GeneratedVisitor;
5139
5140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5141 type Value = GeneratedField;
5142
5143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5144 write!(formatter, "expected one of: {:?}", &FIELDS)
5145 }
5146
5147 #[allow(unused_variables)]
5148 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5149 where
5150 E: serde::de::Error,
5151 {
5152 match value {
5153 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5154 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5155 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5156 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5157 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5158 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5159 }
5160 }
5161 }
5162 deserializer.deserialize_identifier(GeneratedVisitor)
5163 }
5164 }
5165 struct GeneratedVisitor;
5166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5167 type Value = GroupDelta;
5168
5169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5170 formatter.write_str("struct hummock.GroupDelta")
5171 }
5172
5173 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5174 where
5175 V: serde::de::MapAccess<'de>,
5176 {
5177 let mut delta_type__ = None;
5178 while let Some(k) = map_.next_key()? {
5179 match k {
5180 GeneratedField::IntraLevel => {
5181 if delta_type__.is_some() {
5182 return Err(serde::de::Error::duplicate_field("intraLevel"));
5183 }
5184 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5185;
5186 }
5187 GeneratedField::GroupConstruct => {
5188 if delta_type__.is_some() {
5189 return Err(serde::de::Error::duplicate_field("groupConstruct"));
5190 }
5191 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5192;
5193 }
5194 GeneratedField::GroupDestroy => {
5195 if delta_type__.is_some() {
5196 return Err(serde::de::Error::duplicate_field("groupDestroy"));
5197 }
5198 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5199;
5200 }
5201 GeneratedField::GroupMerge => {
5202 if delta_type__.is_some() {
5203 return Err(serde::de::Error::duplicate_field("groupMerge"));
5204 }
5205 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5206;
5207 }
5208 GeneratedField::NewL0SubLevel => {
5209 if delta_type__.is_some() {
5210 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5211 }
5212 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5213;
5214 }
5215 }
5216 }
5217 Ok(GroupDelta {
5218 delta_type: delta_type__,
5219 })
5220 }
5221 }
5222 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5223 }
5224}
5225impl serde::Serialize for GroupDestroy {
5226 #[allow(deprecated)]
5227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5228 where
5229 S: serde::Serializer,
5230 {
5231 use serde::ser::SerializeStruct;
5232 let len = 0;
5233 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5234 struct_ser.end()
5235 }
5236}
5237impl<'de> serde::Deserialize<'de> for GroupDestroy {
5238 #[allow(deprecated)]
5239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5240 where
5241 D: serde::Deserializer<'de>,
5242 {
5243 const FIELDS: &[&str] = &[
5244 ];
5245
5246 #[allow(clippy::enum_variant_names)]
5247 enum GeneratedField {
5248 }
5249 impl<'de> serde::Deserialize<'de> for GeneratedField {
5250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5251 where
5252 D: serde::Deserializer<'de>,
5253 {
5254 struct GeneratedVisitor;
5255
5256 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5257 type Value = GeneratedField;
5258
5259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5260 write!(formatter, "expected one of: {:?}", &FIELDS)
5261 }
5262
5263 #[allow(unused_variables)]
5264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5265 where
5266 E: serde::de::Error,
5267 {
5268 Err(serde::de::Error::unknown_field(value, FIELDS))
5269 }
5270 }
5271 deserializer.deserialize_identifier(GeneratedVisitor)
5272 }
5273 }
5274 struct GeneratedVisitor;
5275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5276 type Value = GroupDestroy;
5277
5278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5279 formatter.write_str("struct hummock.GroupDestroy")
5280 }
5281
5282 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5283 where
5284 V: serde::de::MapAccess<'de>,
5285 {
5286 while map_.next_key::<GeneratedField>()?.is_some() {
5287 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5288 }
5289 Ok(GroupDestroy {
5290 })
5291 }
5292 }
5293 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5294 }
5295}
5296impl serde::Serialize for GroupMerge {
5297 #[allow(deprecated)]
5298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5299 where
5300 S: serde::Serializer,
5301 {
5302 use serde::ser::SerializeStruct;
5303 let mut len = 0;
5304 if self.left_group_id != 0 {
5305 len += 1;
5306 }
5307 if self.right_group_id != 0 {
5308 len += 1;
5309 }
5310 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5311 if self.left_group_id != 0 {
5312 #[allow(clippy::needless_borrow)]
5313 #[allow(clippy::needless_borrows_for_generic_args)]
5314 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5315 }
5316 if self.right_group_id != 0 {
5317 #[allow(clippy::needless_borrow)]
5318 #[allow(clippy::needless_borrows_for_generic_args)]
5319 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5320 }
5321 struct_ser.end()
5322 }
5323}
5324impl<'de> serde::Deserialize<'de> for GroupMerge {
5325 #[allow(deprecated)]
5326 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5327 where
5328 D: serde::Deserializer<'de>,
5329 {
5330 const FIELDS: &[&str] = &[
5331 "left_group_id",
5332 "leftGroupId",
5333 "right_group_id",
5334 "rightGroupId",
5335 ];
5336
5337 #[allow(clippy::enum_variant_names)]
5338 enum GeneratedField {
5339 LeftGroupId,
5340 RightGroupId,
5341 }
5342 impl<'de> serde::Deserialize<'de> for GeneratedField {
5343 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5344 where
5345 D: serde::Deserializer<'de>,
5346 {
5347 struct GeneratedVisitor;
5348
5349 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5350 type Value = GeneratedField;
5351
5352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5353 write!(formatter, "expected one of: {:?}", &FIELDS)
5354 }
5355
5356 #[allow(unused_variables)]
5357 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5358 where
5359 E: serde::de::Error,
5360 {
5361 match value {
5362 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5363 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5364 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5365 }
5366 }
5367 }
5368 deserializer.deserialize_identifier(GeneratedVisitor)
5369 }
5370 }
5371 struct GeneratedVisitor;
5372 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5373 type Value = GroupMerge;
5374
5375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5376 formatter.write_str("struct hummock.GroupMerge")
5377 }
5378
5379 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5380 where
5381 V: serde::de::MapAccess<'de>,
5382 {
5383 let mut left_group_id__ = None;
5384 let mut right_group_id__ = None;
5385 while let Some(k) = map_.next_key()? {
5386 match k {
5387 GeneratedField::LeftGroupId => {
5388 if left_group_id__.is_some() {
5389 return Err(serde::de::Error::duplicate_field("leftGroupId"));
5390 }
5391 left_group_id__ =
5392 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5393 ;
5394 }
5395 GeneratedField::RightGroupId => {
5396 if right_group_id__.is_some() {
5397 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5398 }
5399 right_group_id__ =
5400 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5401 ;
5402 }
5403 }
5404 }
5405 Ok(GroupMerge {
5406 left_group_id: left_group_id__.unwrap_or_default(),
5407 right_group_id: right_group_id__.unwrap_or_default(),
5408 })
5409 }
5410 }
5411 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5412 }
5413}
5414impl serde::Serialize for HummockPinnedSnapshot {
5415 #[allow(deprecated)]
5416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5417 where
5418 S: serde::Serializer,
5419 {
5420 use serde::ser::SerializeStruct;
5421 let mut len = 0;
5422 if self.context_id != 0 {
5423 len += 1;
5424 }
5425 if self.minimal_pinned_snapshot != 0 {
5426 len += 1;
5427 }
5428 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
5429 if self.context_id != 0 {
5430 struct_ser.serialize_field("contextId", &self.context_id)?;
5431 }
5432 if self.minimal_pinned_snapshot != 0 {
5433 #[allow(clippy::needless_borrow)]
5434 #[allow(clippy::needless_borrows_for_generic_args)]
5435 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
5436 }
5437 struct_ser.end()
5438 }
5439}
5440impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
5441 #[allow(deprecated)]
5442 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5443 where
5444 D: serde::Deserializer<'de>,
5445 {
5446 const FIELDS: &[&str] = &[
5447 "context_id",
5448 "contextId",
5449 "minimal_pinned_snapshot",
5450 "minimalPinnedSnapshot",
5451 ];
5452
5453 #[allow(clippy::enum_variant_names)]
5454 enum GeneratedField {
5455 ContextId,
5456 MinimalPinnedSnapshot,
5457 }
5458 impl<'de> serde::Deserialize<'de> for GeneratedField {
5459 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5460 where
5461 D: serde::Deserializer<'de>,
5462 {
5463 struct GeneratedVisitor;
5464
5465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5466 type Value = GeneratedField;
5467
5468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5469 write!(formatter, "expected one of: {:?}", &FIELDS)
5470 }
5471
5472 #[allow(unused_variables)]
5473 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5474 where
5475 E: serde::de::Error,
5476 {
5477 match value {
5478 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5479 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
5480 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5481 }
5482 }
5483 }
5484 deserializer.deserialize_identifier(GeneratedVisitor)
5485 }
5486 }
5487 struct GeneratedVisitor;
5488 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5489 type Value = HummockPinnedSnapshot;
5490
5491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5492 formatter.write_str("struct hummock.HummockPinnedSnapshot")
5493 }
5494
5495 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
5496 where
5497 V: serde::de::MapAccess<'de>,
5498 {
5499 let mut context_id__ = None;
5500 let mut minimal_pinned_snapshot__ = None;
5501 while let Some(k) = map_.next_key()? {
5502 match k {
5503 GeneratedField::ContextId => {
5504 if context_id__.is_some() {
5505 return Err(serde::de::Error::duplicate_field("contextId"));
5506 }
5507 context_id__ =
5508 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5509 ;
5510 }
5511 GeneratedField::MinimalPinnedSnapshot => {
5512 if minimal_pinned_snapshot__.is_some() {
5513 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
5514 }
5515 minimal_pinned_snapshot__ =
5516 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5517 ;
5518 }
5519 }
5520 }
5521 Ok(HummockPinnedSnapshot {
5522 context_id: context_id__.unwrap_or_default(),
5523 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
5524 })
5525 }
5526 }
5527 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
5528 }
5529}
5530impl serde::Serialize for HummockPinnedVersion {
5531 #[allow(deprecated)]
5532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5533 where
5534 S: serde::Serializer,
5535 {
5536 use serde::ser::SerializeStruct;
5537 let mut len = 0;
5538 if self.context_id != 0 {
5539 len += 1;
5540 }
5541 if self.min_pinned_id != 0 {
5542 len += 1;
5543 }
5544 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
5545 if self.context_id != 0 {
5546 struct_ser.serialize_field("contextId", &self.context_id)?;
5547 }
5548 if self.min_pinned_id != 0 {
5549 #[allow(clippy::needless_borrow)]
5550 #[allow(clippy::needless_borrows_for_generic_args)]
5551 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
5552 }
5553 struct_ser.end()
5554 }
5555}
5556impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
5557 #[allow(deprecated)]
5558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5559 where
5560 D: serde::Deserializer<'de>,
5561 {
5562 const FIELDS: &[&str] = &[
5563 "context_id",
5564 "contextId",
5565 "min_pinned_id",
5566 "minPinnedId",
5567 ];
5568
5569 #[allow(clippy::enum_variant_names)]
5570 enum GeneratedField {
5571 ContextId,
5572 MinPinnedId,
5573 }
5574 impl<'de> serde::Deserialize<'de> for GeneratedField {
5575 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5576 where
5577 D: serde::Deserializer<'de>,
5578 {
5579 struct GeneratedVisitor;
5580
5581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5582 type Value = GeneratedField;
5583
5584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5585 write!(formatter, "expected one of: {:?}", &FIELDS)
5586 }
5587
5588 #[allow(unused_variables)]
5589 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5590 where
5591 E: serde::de::Error,
5592 {
5593 match value {
5594 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5595 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
5596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5597 }
5598 }
5599 }
5600 deserializer.deserialize_identifier(GeneratedVisitor)
5601 }
5602 }
5603 struct GeneratedVisitor;
5604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5605 type Value = HummockPinnedVersion;
5606
5607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5608 formatter.write_str("struct hummock.HummockPinnedVersion")
5609 }
5610
5611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
5612 where
5613 V: serde::de::MapAccess<'de>,
5614 {
5615 let mut context_id__ = None;
5616 let mut min_pinned_id__ = None;
5617 while let Some(k) = map_.next_key()? {
5618 match k {
5619 GeneratedField::ContextId => {
5620 if context_id__.is_some() {
5621 return Err(serde::de::Error::duplicate_field("contextId"));
5622 }
5623 context_id__ =
5624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5625 ;
5626 }
5627 GeneratedField::MinPinnedId => {
5628 if min_pinned_id__.is_some() {
5629 return Err(serde::de::Error::duplicate_field("minPinnedId"));
5630 }
5631 min_pinned_id__ =
5632 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5633 ;
5634 }
5635 }
5636 }
5637 Ok(HummockPinnedVersion {
5638 context_id: context_id__.unwrap_or_default(),
5639 min_pinned_id: min_pinned_id__.unwrap_or_default(),
5640 })
5641 }
5642 }
5643 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
5644 }
5645}
5646impl serde::Serialize for HummockVersion {
5647 #[allow(deprecated)]
5648 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5649 where
5650 S: serde::Serializer,
5651 {
5652 use serde::ser::SerializeStruct;
5653 let mut len = 0;
5654 if self.id != 0 {
5655 len += 1;
5656 }
5657 if !self.levels.is_empty() {
5658 len += 1;
5659 }
5660 if self.max_committed_epoch != 0 {
5661 len += 1;
5662 }
5663 if !self.table_watermarks.is_empty() {
5664 len += 1;
5665 }
5666 if !self.table_change_logs.is_empty() {
5667 len += 1;
5668 }
5669 if !self.state_table_info.is_empty() {
5670 len += 1;
5671 }
5672 if !self.vector_indexes.is_empty() {
5673 len += 1;
5674 }
5675 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
5676 if self.id != 0 {
5677 #[allow(clippy::needless_borrow)]
5678 #[allow(clippy::needless_borrows_for_generic_args)]
5679 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
5680 }
5681 if !self.levels.is_empty() {
5682 struct_ser.serialize_field("levels", &self.levels)?;
5683 }
5684 if self.max_committed_epoch != 0 {
5685 #[allow(clippy::needless_borrow)]
5686 #[allow(clippy::needless_borrows_for_generic_args)]
5687 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
5688 }
5689 if !self.table_watermarks.is_empty() {
5690 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
5691 }
5692 if !self.table_change_logs.is_empty() {
5693 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
5694 }
5695 if !self.state_table_info.is_empty() {
5696 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
5697 }
5698 if !self.vector_indexes.is_empty() {
5699 struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
5700 }
5701 struct_ser.end()
5702 }
5703}
5704impl<'de> serde::Deserialize<'de> for HummockVersion {
5705 #[allow(deprecated)]
5706 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5707 where
5708 D: serde::Deserializer<'de>,
5709 {
5710 const FIELDS: &[&str] = &[
5711 "id",
5712 "levels",
5713 "max_committed_epoch",
5714 "maxCommittedEpoch",
5715 "table_watermarks",
5716 "tableWatermarks",
5717 "table_change_logs",
5718 "tableChangeLogs",
5719 "state_table_info",
5720 "stateTableInfo",
5721 "vector_indexes",
5722 "vectorIndexes",
5723 ];
5724
5725 #[allow(clippy::enum_variant_names)]
5726 enum GeneratedField {
5727 Id,
5728 Levels,
5729 MaxCommittedEpoch,
5730 TableWatermarks,
5731 TableChangeLogs,
5732 StateTableInfo,
5733 VectorIndexes,
5734 }
5735 impl<'de> serde::Deserialize<'de> for GeneratedField {
5736 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5737 where
5738 D: serde::Deserializer<'de>,
5739 {
5740 struct GeneratedVisitor;
5741
5742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5743 type Value = GeneratedField;
5744
5745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5746 write!(formatter, "expected one of: {:?}", &FIELDS)
5747 }
5748
5749 #[allow(unused_variables)]
5750 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5751 where
5752 E: serde::de::Error,
5753 {
5754 match value {
5755 "id" => Ok(GeneratedField::Id),
5756 "levels" => Ok(GeneratedField::Levels),
5757 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
5758 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
5759 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
5760 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
5761 "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
5762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5763 }
5764 }
5765 }
5766 deserializer.deserialize_identifier(GeneratedVisitor)
5767 }
5768 }
5769 struct GeneratedVisitor;
5770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5771 type Value = HummockVersion;
5772
5773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5774 formatter.write_str("struct hummock.HummockVersion")
5775 }
5776
5777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
5778 where
5779 V: serde::de::MapAccess<'de>,
5780 {
5781 let mut id__ = None;
5782 let mut levels__ = None;
5783 let mut max_committed_epoch__ = None;
5784 let mut table_watermarks__ = None;
5785 let mut table_change_logs__ = None;
5786 let mut state_table_info__ = None;
5787 let mut vector_indexes__ = None;
5788 while let Some(k) = map_.next_key()? {
5789 match k {
5790 GeneratedField::Id => {
5791 if id__.is_some() {
5792 return Err(serde::de::Error::duplicate_field("id"));
5793 }
5794 id__ =
5795 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5796 ;
5797 }
5798 GeneratedField::Levels => {
5799 if levels__.is_some() {
5800 return Err(serde::de::Error::duplicate_field("levels"));
5801 }
5802 levels__ = Some(
5803 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
5804 .into_iter().map(|(k,v)| (k.0, v)).collect()
5805 );
5806 }
5807 GeneratedField::MaxCommittedEpoch => {
5808 if max_committed_epoch__.is_some() {
5809 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
5810 }
5811 max_committed_epoch__ =
5812 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5813 ;
5814 }
5815 GeneratedField::TableWatermarks => {
5816 if table_watermarks__.is_some() {
5817 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
5818 }
5819 table_watermarks__ = Some(
5820 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5821 .into_iter().map(|(k,v)| (k.0, v)).collect()
5822 );
5823 }
5824 GeneratedField::TableChangeLogs => {
5825 if table_change_logs__.is_some() {
5826 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
5827 }
5828 table_change_logs__ = Some(
5829 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5830 .into_iter().map(|(k,v)| (k.0, v)).collect()
5831 );
5832 }
5833 GeneratedField::StateTableInfo => {
5834 if state_table_info__.is_some() {
5835 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
5836 }
5837 state_table_info__ = Some(
5838 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5839 .into_iter().map(|(k,v)| (k.0, v)).collect()
5840 );
5841 }
5842 GeneratedField::VectorIndexes => {
5843 if vector_indexes__.is_some() {
5844 return Err(serde::de::Error::duplicate_field("vectorIndexes"));
5845 }
5846 vector_indexes__ = Some(
5847 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5848 .into_iter().map(|(k,v)| (k.0, v)).collect()
5849 );
5850 }
5851 }
5852 }
5853 Ok(HummockVersion {
5854 id: id__.unwrap_or_default(),
5855 levels: levels__.unwrap_or_default(),
5856 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
5857 table_watermarks: table_watermarks__.unwrap_or_default(),
5858 table_change_logs: table_change_logs__.unwrap_or_default(),
5859 state_table_info: state_table_info__.unwrap_or_default(),
5860 vector_indexes: vector_indexes__.unwrap_or_default(),
5861 })
5862 }
5863 }
5864 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
5865 }
5866}
5867impl serde::Serialize for hummock_version::Levels {
5868 #[allow(deprecated)]
5869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5870 where
5871 S: serde::Serializer,
5872 {
5873 use serde::ser::SerializeStruct;
5874 let mut len = 0;
5875 if !self.levels.is_empty() {
5876 len += 1;
5877 }
5878 if self.l0.is_some() {
5879 len += 1;
5880 }
5881 if self.group_id != 0 {
5882 len += 1;
5883 }
5884 if self.parent_group_id != 0 {
5885 len += 1;
5886 }
5887 if !self.member_table_ids.is_empty() {
5888 len += 1;
5889 }
5890 if self.compaction_group_version_id != 0 {
5891 len += 1;
5892 }
5893 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
5894 if !self.levels.is_empty() {
5895 struct_ser.serialize_field("levels", &self.levels)?;
5896 }
5897 if let Some(v) = self.l0.as_ref() {
5898 struct_ser.serialize_field("l0", v)?;
5899 }
5900 if self.group_id != 0 {
5901 #[allow(clippy::needless_borrow)]
5902 #[allow(clippy::needless_borrows_for_generic_args)]
5903 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
5904 }
5905 if self.parent_group_id != 0 {
5906 #[allow(clippy::needless_borrow)]
5907 #[allow(clippy::needless_borrows_for_generic_args)]
5908 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
5909 }
5910 if !self.member_table_ids.is_empty() {
5911 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
5912 }
5913 if self.compaction_group_version_id != 0 {
5914 #[allow(clippy::needless_borrow)]
5915 #[allow(clippy::needless_borrows_for_generic_args)]
5916 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
5917 }
5918 struct_ser.end()
5919 }
5920}
5921impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
5922 #[allow(deprecated)]
5923 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5924 where
5925 D: serde::Deserializer<'de>,
5926 {
5927 const FIELDS: &[&str] = &[
5928 "levels",
5929 "l0",
5930 "group_id",
5931 "groupId",
5932 "parent_group_id",
5933 "parentGroupId",
5934 "member_table_ids",
5935 "memberTableIds",
5936 "compaction_group_version_id",
5937 "compactionGroupVersionId",
5938 ];
5939
5940 #[allow(clippy::enum_variant_names)]
5941 enum GeneratedField {
5942 Levels,
5943 L0,
5944 GroupId,
5945 ParentGroupId,
5946 MemberTableIds,
5947 CompactionGroupVersionId,
5948 }
5949 impl<'de> serde::Deserialize<'de> for GeneratedField {
5950 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5951 where
5952 D: serde::Deserializer<'de>,
5953 {
5954 struct GeneratedVisitor;
5955
5956 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5957 type Value = GeneratedField;
5958
5959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5960 write!(formatter, "expected one of: {:?}", &FIELDS)
5961 }
5962
5963 #[allow(unused_variables)]
5964 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5965 where
5966 E: serde::de::Error,
5967 {
5968 match value {
5969 "levels" => Ok(GeneratedField::Levels),
5970 "l0" => Ok(GeneratedField::L0),
5971 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
5972 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
5973 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
5974 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
5975 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5976 }
5977 }
5978 }
5979 deserializer.deserialize_identifier(GeneratedVisitor)
5980 }
5981 }
5982 struct GeneratedVisitor;
5983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5984 type Value = hummock_version::Levels;
5985
5986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5987 formatter.write_str("struct hummock.HummockVersion.Levels")
5988 }
5989
5990 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
5991 where
5992 V: serde::de::MapAccess<'de>,
5993 {
5994 let mut levels__ = None;
5995 let mut l0__ = None;
5996 let mut group_id__ = None;
5997 let mut parent_group_id__ = None;
5998 let mut member_table_ids__ = None;
5999 let mut compaction_group_version_id__ = None;
6000 while let Some(k) = map_.next_key()? {
6001 match k {
6002 GeneratedField::Levels => {
6003 if levels__.is_some() {
6004 return Err(serde::de::Error::duplicate_field("levels"));
6005 }
6006 levels__ = Some(map_.next_value()?);
6007 }
6008 GeneratedField::L0 => {
6009 if l0__.is_some() {
6010 return Err(serde::de::Error::duplicate_field("l0"));
6011 }
6012 l0__ = map_.next_value()?;
6013 }
6014 GeneratedField::GroupId => {
6015 if group_id__.is_some() {
6016 return Err(serde::de::Error::duplicate_field("groupId"));
6017 }
6018 group_id__ =
6019 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6020 ;
6021 }
6022 GeneratedField::ParentGroupId => {
6023 if parent_group_id__.is_some() {
6024 return Err(serde::de::Error::duplicate_field("parentGroupId"));
6025 }
6026 parent_group_id__ =
6027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6028 ;
6029 }
6030 GeneratedField::MemberTableIds => {
6031 if member_table_ids__.is_some() {
6032 return Err(serde::de::Error::duplicate_field("memberTableIds"));
6033 }
6034 member_table_ids__ =
6035 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6036 .into_iter().map(|x| x.0).collect())
6037 ;
6038 }
6039 GeneratedField::CompactionGroupVersionId => {
6040 if compaction_group_version_id__.is_some() {
6041 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
6042 }
6043 compaction_group_version_id__ =
6044 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6045 ;
6046 }
6047 }
6048 }
6049 Ok(hummock_version::Levels {
6050 levels: levels__.unwrap_or_default(),
6051 l0: l0__,
6052 group_id: group_id__.unwrap_or_default(),
6053 parent_group_id: parent_group_id__.unwrap_or_default(),
6054 member_table_ids: member_table_ids__.unwrap_or_default(),
6055 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
6056 })
6057 }
6058 }
6059 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
6060 }
6061}
6062impl serde::Serialize for HummockVersionArchive {
6063 #[allow(deprecated)]
6064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6065 where
6066 S: serde::Serializer,
6067 {
6068 use serde::ser::SerializeStruct;
6069 let mut len = 0;
6070 if self.version.is_some() {
6071 len += 1;
6072 }
6073 if !self.version_deltas.is_empty() {
6074 len += 1;
6075 }
6076 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
6077 if let Some(v) = self.version.as_ref() {
6078 struct_ser.serialize_field("version", v)?;
6079 }
6080 if !self.version_deltas.is_empty() {
6081 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6082 }
6083 struct_ser.end()
6084 }
6085}
6086impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
6087 #[allow(deprecated)]
6088 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6089 where
6090 D: serde::Deserializer<'de>,
6091 {
6092 const FIELDS: &[&str] = &[
6093 "version",
6094 "version_deltas",
6095 "versionDeltas",
6096 ];
6097
6098 #[allow(clippy::enum_variant_names)]
6099 enum GeneratedField {
6100 Version,
6101 VersionDeltas,
6102 }
6103 impl<'de> serde::Deserialize<'de> for GeneratedField {
6104 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6105 where
6106 D: serde::Deserializer<'de>,
6107 {
6108 struct GeneratedVisitor;
6109
6110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6111 type Value = GeneratedField;
6112
6113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6114 write!(formatter, "expected one of: {:?}", &FIELDS)
6115 }
6116
6117 #[allow(unused_variables)]
6118 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6119 where
6120 E: serde::de::Error,
6121 {
6122 match value {
6123 "version" => Ok(GeneratedField::Version),
6124 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6125 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6126 }
6127 }
6128 }
6129 deserializer.deserialize_identifier(GeneratedVisitor)
6130 }
6131 }
6132 struct GeneratedVisitor;
6133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6134 type Value = HummockVersionArchive;
6135
6136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6137 formatter.write_str("struct hummock.HummockVersionArchive")
6138 }
6139
6140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
6141 where
6142 V: serde::de::MapAccess<'de>,
6143 {
6144 let mut version__ = None;
6145 let mut version_deltas__ = None;
6146 while let Some(k) = map_.next_key()? {
6147 match k {
6148 GeneratedField::Version => {
6149 if version__.is_some() {
6150 return Err(serde::de::Error::duplicate_field("version"));
6151 }
6152 version__ = map_.next_value()?;
6153 }
6154 GeneratedField::VersionDeltas => {
6155 if version_deltas__.is_some() {
6156 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6157 }
6158 version_deltas__ = Some(map_.next_value()?);
6159 }
6160 }
6161 }
6162 Ok(HummockVersionArchive {
6163 version: version__,
6164 version_deltas: version_deltas__.unwrap_or_default(),
6165 })
6166 }
6167 }
6168 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
6169 }
6170}
6171impl serde::Serialize for HummockVersionCheckpoint {
6172 #[allow(deprecated)]
6173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6174 where
6175 S: serde::Serializer,
6176 {
6177 use serde::ser::SerializeStruct;
6178 let mut len = 0;
6179 if self.version.is_some() {
6180 len += 1;
6181 }
6182 if !self.stale_objects.is_empty() {
6183 len += 1;
6184 }
6185 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
6186 if let Some(v) = self.version.as_ref() {
6187 struct_ser.serialize_field("version", v)?;
6188 }
6189 if !self.stale_objects.is_empty() {
6190 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
6191 }
6192 struct_ser.end()
6193 }
6194}
6195impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
6196 #[allow(deprecated)]
6197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6198 where
6199 D: serde::Deserializer<'de>,
6200 {
6201 const FIELDS: &[&str] = &[
6202 "version",
6203 "stale_objects",
6204 "staleObjects",
6205 ];
6206
6207 #[allow(clippy::enum_variant_names)]
6208 enum GeneratedField {
6209 Version,
6210 StaleObjects,
6211 }
6212 impl<'de> serde::Deserialize<'de> for GeneratedField {
6213 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6214 where
6215 D: serde::Deserializer<'de>,
6216 {
6217 struct GeneratedVisitor;
6218
6219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6220 type Value = GeneratedField;
6221
6222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6223 write!(formatter, "expected one of: {:?}", &FIELDS)
6224 }
6225
6226 #[allow(unused_variables)]
6227 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6228 where
6229 E: serde::de::Error,
6230 {
6231 match value {
6232 "version" => Ok(GeneratedField::Version),
6233 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
6234 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6235 }
6236 }
6237 }
6238 deserializer.deserialize_identifier(GeneratedVisitor)
6239 }
6240 }
6241 struct GeneratedVisitor;
6242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6243 type Value = HummockVersionCheckpoint;
6244
6245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6246 formatter.write_str("struct hummock.HummockVersionCheckpoint")
6247 }
6248
6249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
6250 where
6251 V: serde::de::MapAccess<'de>,
6252 {
6253 let mut version__ = None;
6254 let mut stale_objects__ = None;
6255 while let Some(k) = map_.next_key()? {
6256 match k {
6257 GeneratedField::Version => {
6258 if version__.is_some() {
6259 return Err(serde::de::Error::duplicate_field("version"));
6260 }
6261 version__ = map_.next_value()?;
6262 }
6263 GeneratedField::StaleObjects => {
6264 if stale_objects__.is_some() {
6265 return Err(serde::de::Error::duplicate_field("staleObjects"));
6266 }
6267 stale_objects__ = Some(
6268 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6269 .into_iter().map(|(k,v)| (k.0, v)).collect()
6270 );
6271 }
6272 }
6273 }
6274 Ok(HummockVersionCheckpoint {
6275 version: version__,
6276 stale_objects: stale_objects__.unwrap_or_default(),
6277 })
6278 }
6279 }
6280 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
6281 }
6282}
6283impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
6284 #[allow(deprecated)]
6285 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6286 where
6287 S: serde::Serializer,
6288 {
6289 use serde::ser::SerializeStruct;
6290 let mut len = 0;
6291 if !self.id.is_empty() {
6292 len += 1;
6293 }
6294 if self.total_file_size != 0 {
6295 len += 1;
6296 }
6297 if !self.vector_files.is_empty() {
6298 len += 1;
6299 }
6300 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
6301 if !self.id.is_empty() {
6302 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
6303 }
6304 if self.total_file_size != 0 {
6305 #[allow(clippy::needless_borrow)]
6306 #[allow(clippy::needless_borrows_for_generic_args)]
6307 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
6308 }
6309 if !self.vector_files.is_empty() {
6310 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
6311 }
6312 struct_ser.end()
6313 }
6314}
6315impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
6316 #[allow(deprecated)]
6317 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6318 where
6319 D: serde::Deserializer<'de>,
6320 {
6321 const FIELDS: &[&str] = &[
6322 "id",
6323 "total_file_size",
6324 "totalFileSize",
6325 "vector_files",
6326 "vectorFiles",
6327 ];
6328
6329 #[allow(clippy::enum_variant_names)]
6330 enum GeneratedField {
6331 Id,
6332 TotalFileSize,
6333 VectorFiles,
6334 }
6335 impl<'de> serde::Deserialize<'de> for GeneratedField {
6336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6337 where
6338 D: serde::Deserializer<'de>,
6339 {
6340 struct GeneratedVisitor;
6341
6342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6343 type Value = GeneratedField;
6344
6345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6346 write!(formatter, "expected one of: {:?}", &FIELDS)
6347 }
6348
6349 #[allow(unused_variables)]
6350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6351 where
6352 E: serde::de::Error,
6353 {
6354 match value {
6355 "id" => Ok(GeneratedField::Id),
6356 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
6357 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
6358 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6359 }
6360 }
6361 }
6362 deserializer.deserialize_identifier(GeneratedVisitor)
6363 }
6364 }
6365 struct GeneratedVisitor;
6366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6367 type Value = hummock_version_checkpoint::StaleObjects;
6368
6369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6370 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
6371 }
6372
6373 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
6374 where
6375 V: serde::de::MapAccess<'de>,
6376 {
6377 let mut id__ = None;
6378 let mut total_file_size__ = None;
6379 let mut vector_files__ = None;
6380 while let Some(k) = map_.next_key()? {
6381 match k {
6382 GeneratedField::Id => {
6383 if id__.is_some() {
6384 return Err(serde::de::Error::duplicate_field("id"));
6385 }
6386 id__ =
6387 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6388 .into_iter().map(|x| x.0).collect())
6389 ;
6390 }
6391 GeneratedField::TotalFileSize => {
6392 if total_file_size__.is_some() {
6393 return Err(serde::de::Error::duplicate_field("totalFileSize"));
6394 }
6395 total_file_size__ =
6396 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6397 ;
6398 }
6399 GeneratedField::VectorFiles => {
6400 if vector_files__.is_some() {
6401 return Err(serde::de::Error::duplicate_field("vectorFiles"));
6402 }
6403 vector_files__ = Some(map_.next_value()?);
6404 }
6405 }
6406 }
6407 Ok(hummock_version_checkpoint::StaleObjects {
6408 id: id__.unwrap_or_default(),
6409 total_file_size: total_file_size__.unwrap_or_default(),
6410 vector_files: vector_files__.unwrap_or_default(),
6411 })
6412 }
6413 }
6414 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
6415 }
6416}
6417impl serde::Serialize for HummockVersionDelta {
6418 #[allow(deprecated)]
6419 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6420 where
6421 S: serde::Serializer,
6422 {
6423 use serde::ser::SerializeStruct;
6424 let mut len = 0;
6425 if self.id != 0 {
6426 len += 1;
6427 }
6428 if self.prev_id != 0 {
6429 len += 1;
6430 }
6431 if !self.group_deltas.is_empty() {
6432 len += 1;
6433 }
6434 if self.max_committed_epoch != 0 {
6435 len += 1;
6436 }
6437 if self.trivial_move {
6438 len += 1;
6439 }
6440 if !self.new_table_watermarks.is_empty() {
6441 len += 1;
6442 }
6443 if !self.removed_table_ids.is_empty() {
6444 len += 1;
6445 }
6446 if !self.change_log_delta.is_empty() {
6447 len += 1;
6448 }
6449 if !self.state_table_info_delta.is_empty() {
6450 len += 1;
6451 }
6452 if !self.vector_index_delta.is_empty() {
6453 len += 1;
6454 }
6455 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
6456 if self.id != 0 {
6457 #[allow(clippy::needless_borrow)]
6458 #[allow(clippy::needless_borrows_for_generic_args)]
6459 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6460 }
6461 if self.prev_id != 0 {
6462 #[allow(clippy::needless_borrow)]
6463 #[allow(clippy::needless_borrows_for_generic_args)]
6464 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
6465 }
6466 if !self.group_deltas.is_empty() {
6467 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6468 }
6469 if self.max_committed_epoch != 0 {
6470 #[allow(clippy::needless_borrow)]
6471 #[allow(clippy::needless_borrows_for_generic_args)]
6472 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6473 }
6474 if self.trivial_move {
6475 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
6476 }
6477 if !self.new_table_watermarks.is_empty() {
6478 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
6479 }
6480 if !self.removed_table_ids.is_empty() {
6481 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
6482 }
6483 if !self.change_log_delta.is_empty() {
6484 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
6485 }
6486 if !self.state_table_info_delta.is_empty() {
6487 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
6488 }
6489 if !self.vector_index_delta.is_empty() {
6490 struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
6491 }
6492 struct_ser.end()
6493 }
6494}
6495impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
6496 #[allow(deprecated)]
6497 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6498 where
6499 D: serde::Deserializer<'de>,
6500 {
6501 const FIELDS: &[&str] = &[
6502 "id",
6503 "prev_id",
6504 "prevId",
6505 "group_deltas",
6506 "groupDeltas",
6507 "max_committed_epoch",
6508 "maxCommittedEpoch",
6509 "trivial_move",
6510 "trivialMove",
6511 "new_table_watermarks",
6512 "newTableWatermarks",
6513 "removed_table_ids",
6514 "removedTableIds",
6515 "change_log_delta",
6516 "changeLogDelta",
6517 "state_table_info_delta",
6518 "stateTableInfoDelta",
6519 "vector_index_delta",
6520 "vectorIndexDelta",
6521 ];
6522
6523 #[allow(clippy::enum_variant_names)]
6524 enum GeneratedField {
6525 Id,
6526 PrevId,
6527 GroupDeltas,
6528 MaxCommittedEpoch,
6529 TrivialMove,
6530 NewTableWatermarks,
6531 RemovedTableIds,
6532 ChangeLogDelta,
6533 StateTableInfoDelta,
6534 VectorIndexDelta,
6535 }
6536 impl<'de> serde::Deserialize<'de> for GeneratedField {
6537 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6538 where
6539 D: serde::Deserializer<'de>,
6540 {
6541 struct GeneratedVisitor;
6542
6543 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6544 type Value = GeneratedField;
6545
6546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6547 write!(formatter, "expected one of: {:?}", &FIELDS)
6548 }
6549
6550 #[allow(unused_variables)]
6551 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6552 where
6553 E: serde::de::Error,
6554 {
6555 match value {
6556 "id" => Ok(GeneratedField::Id),
6557 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
6558 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6559 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6560 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
6561 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
6562 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
6563 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
6564 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
6565 "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
6566 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6567 }
6568 }
6569 }
6570 deserializer.deserialize_identifier(GeneratedVisitor)
6571 }
6572 }
6573 struct GeneratedVisitor;
6574 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6575 type Value = HummockVersionDelta;
6576
6577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6578 formatter.write_str("struct hummock.HummockVersionDelta")
6579 }
6580
6581 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
6582 where
6583 V: serde::de::MapAccess<'de>,
6584 {
6585 let mut id__ = None;
6586 let mut prev_id__ = None;
6587 let mut group_deltas__ = None;
6588 let mut max_committed_epoch__ = None;
6589 let mut trivial_move__ = None;
6590 let mut new_table_watermarks__ = None;
6591 let mut removed_table_ids__ = None;
6592 let mut change_log_delta__ = None;
6593 let mut state_table_info_delta__ = None;
6594 let mut vector_index_delta__ = None;
6595 while let Some(k) = map_.next_key()? {
6596 match k {
6597 GeneratedField::Id => {
6598 if id__.is_some() {
6599 return Err(serde::de::Error::duplicate_field("id"));
6600 }
6601 id__ =
6602 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6603 ;
6604 }
6605 GeneratedField::PrevId => {
6606 if prev_id__.is_some() {
6607 return Err(serde::de::Error::duplicate_field("prevId"));
6608 }
6609 prev_id__ =
6610 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6611 ;
6612 }
6613 GeneratedField::GroupDeltas => {
6614 if group_deltas__.is_some() {
6615 return Err(serde::de::Error::duplicate_field("groupDeltas"));
6616 }
6617 group_deltas__ = Some(
6618 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6619 .into_iter().map(|(k,v)| (k.0, v)).collect()
6620 );
6621 }
6622 GeneratedField::MaxCommittedEpoch => {
6623 if max_committed_epoch__.is_some() {
6624 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
6625 }
6626 max_committed_epoch__ =
6627 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6628 ;
6629 }
6630 GeneratedField::TrivialMove => {
6631 if trivial_move__.is_some() {
6632 return Err(serde::de::Error::duplicate_field("trivialMove"));
6633 }
6634 trivial_move__ = Some(map_.next_value()?);
6635 }
6636 GeneratedField::NewTableWatermarks => {
6637 if new_table_watermarks__.is_some() {
6638 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
6639 }
6640 new_table_watermarks__ = Some(
6641 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6642 .into_iter().map(|(k,v)| (k.0, v)).collect()
6643 );
6644 }
6645 GeneratedField::RemovedTableIds => {
6646 if removed_table_ids__.is_some() {
6647 return Err(serde::de::Error::duplicate_field("removedTableIds"));
6648 }
6649 removed_table_ids__ =
6650 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6651 .into_iter().map(|x| x.0).collect())
6652 ;
6653 }
6654 GeneratedField::ChangeLogDelta => {
6655 if change_log_delta__.is_some() {
6656 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
6657 }
6658 change_log_delta__ = Some(
6659 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6660 .into_iter().map(|(k,v)| (k.0, v)).collect()
6661 );
6662 }
6663 GeneratedField::StateTableInfoDelta => {
6664 if state_table_info_delta__.is_some() {
6665 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
6666 }
6667 state_table_info_delta__ = Some(
6668 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6669 .into_iter().map(|(k,v)| (k.0, v)).collect()
6670 );
6671 }
6672 GeneratedField::VectorIndexDelta => {
6673 if vector_index_delta__.is_some() {
6674 return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
6675 }
6676 vector_index_delta__ = Some(
6677 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6678 .into_iter().map(|(k,v)| (k.0, v)).collect()
6679 );
6680 }
6681 }
6682 }
6683 Ok(HummockVersionDelta {
6684 id: id__.unwrap_or_default(),
6685 prev_id: prev_id__.unwrap_or_default(),
6686 group_deltas: group_deltas__.unwrap_or_default(),
6687 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
6688 trivial_move: trivial_move__.unwrap_or_default(),
6689 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
6690 removed_table_ids: removed_table_ids__.unwrap_or_default(),
6691 change_log_delta: change_log_delta__.unwrap_or_default(),
6692 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
6693 vector_index_delta: vector_index_delta__.unwrap_or_default(),
6694 })
6695 }
6696 }
6697 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
6698 }
6699}
6700impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
6701 #[allow(deprecated)]
6702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6703 where
6704 S: serde::Serializer,
6705 {
6706 use serde::ser::SerializeStruct;
6707 let mut len = 0;
6708 if self.new_log.is_some() {
6709 len += 1;
6710 }
6711 if self.truncate_epoch != 0 {
6712 len += 1;
6713 }
6714 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
6715 if let Some(v) = self.new_log.as_ref() {
6716 struct_ser.serialize_field("newLog", v)?;
6717 }
6718 if self.truncate_epoch != 0 {
6719 #[allow(clippy::needless_borrow)]
6720 #[allow(clippy::needless_borrows_for_generic_args)]
6721 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
6722 }
6723 struct_ser.end()
6724 }
6725}
6726impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
6727 #[allow(deprecated)]
6728 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6729 where
6730 D: serde::Deserializer<'de>,
6731 {
6732 const FIELDS: &[&str] = &[
6733 "new_log",
6734 "newLog",
6735 "truncate_epoch",
6736 "truncateEpoch",
6737 ];
6738
6739 #[allow(clippy::enum_variant_names)]
6740 enum GeneratedField {
6741 NewLog,
6742 TruncateEpoch,
6743 }
6744 impl<'de> serde::Deserialize<'de> for GeneratedField {
6745 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6746 where
6747 D: serde::Deserializer<'de>,
6748 {
6749 struct GeneratedVisitor;
6750
6751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6752 type Value = GeneratedField;
6753
6754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6755 write!(formatter, "expected one of: {:?}", &FIELDS)
6756 }
6757
6758 #[allow(unused_variables)]
6759 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6760 where
6761 E: serde::de::Error,
6762 {
6763 match value {
6764 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
6765 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
6766 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6767 }
6768 }
6769 }
6770 deserializer.deserialize_identifier(GeneratedVisitor)
6771 }
6772 }
6773 struct GeneratedVisitor;
6774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6775 type Value = hummock_version_delta::ChangeLogDelta;
6776
6777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6778 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
6779 }
6780
6781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
6782 where
6783 V: serde::de::MapAccess<'de>,
6784 {
6785 let mut new_log__ = None;
6786 let mut truncate_epoch__ = None;
6787 while let Some(k) = map_.next_key()? {
6788 match k {
6789 GeneratedField::NewLog => {
6790 if new_log__.is_some() {
6791 return Err(serde::de::Error::duplicate_field("newLog"));
6792 }
6793 new_log__ = map_.next_value()?;
6794 }
6795 GeneratedField::TruncateEpoch => {
6796 if truncate_epoch__.is_some() {
6797 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
6798 }
6799 truncate_epoch__ =
6800 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6801 ;
6802 }
6803 }
6804 }
6805 Ok(hummock_version_delta::ChangeLogDelta {
6806 new_log: new_log__,
6807 truncate_epoch: truncate_epoch__.unwrap_or_default(),
6808 })
6809 }
6810 }
6811 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
6812 }
6813}
6814impl serde::Serialize for hummock_version_delta::GroupDeltas {
6815 #[allow(deprecated)]
6816 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6817 where
6818 S: serde::Serializer,
6819 {
6820 use serde::ser::SerializeStruct;
6821 let mut len = 0;
6822 if !self.group_deltas.is_empty() {
6823 len += 1;
6824 }
6825 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
6826 if !self.group_deltas.is_empty() {
6827 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6828 }
6829 struct_ser.end()
6830 }
6831}
6832impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
6833 #[allow(deprecated)]
6834 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6835 where
6836 D: serde::Deserializer<'de>,
6837 {
6838 const FIELDS: &[&str] = &[
6839 "group_deltas",
6840 "groupDeltas",
6841 ];
6842
6843 #[allow(clippy::enum_variant_names)]
6844 enum GeneratedField {
6845 GroupDeltas,
6846 }
6847 impl<'de> serde::Deserialize<'de> for GeneratedField {
6848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6849 where
6850 D: serde::Deserializer<'de>,
6851 {
6852 struct GeneratedVisitor;
6853
6854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6855 type Value = GeneratedField;
6856
6857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6858 write!(formatter, "expected one of: {:?}", &FIELDS)
6859 }
6860
6861 #[allow(unused_variables)]
6862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6863 where
6864 E: serde::de::Error,
6865 {
6866 match value {
6867 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6868 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6869 }
6870 }
6871 }
6872 deserializer.deserialize_identifier(GeneratedVisitor)
6873 }
6874 }
6875 struct GeneratedVisitor;
6876 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6877 type Value = hummock_version_delta::GroupDeltas;
6878
6879 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6880 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
6881 }
6882
6883 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
6884 where
6885 V: serde::de::MapAccess<'de>,
6886 {
6887 let mut group_deltas__ = None;
6888 while let Some(k) = map_.next_key()? {
6889 match k {
6890 GeneratedField::GroupDeltas => {
6891 if group_deltas__.is_some() {
6892 return Err(serde::de::Error::duplicate_field("groupDeltas"));
6893 }
6894 group_deltas__ = Some(map_.next_value()?);
6895 }
6896 }
6897 }
6898 Ok(hummock_version_delta::GroupDeltas {
6899 group_deltas: group_deltas__.unwrap_or_default(),
6900 })
6901 }
6902 }
6903 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
6904 }
6905}
6906impl serde::Serialize for HummockVersionDeltas {
6907 #[allow(deprecated)]
6908 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6909 where
6910 S: serde::Serializer,
6911 {
6912 use serde::ser::SerializeStruct;
6913 let mut len = 0;
6914 if !self.version_deltas.is_empty() {
6915 len += 1;
6916 }
6917 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
6918 if !self.version_deltas.is_empty() {
6919 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6920 }
6921 struct_ser.end()
6922 }
6923}
6924impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
6925 #[allow(deprecated)]
6926 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6927 where
6928 D: serde::Deserializer<'de>,
6929 {
6930 const FIELDS: &[&str] = &[
6931 "version_deltas",
6932 "versionDeltas",
6933 ];
6934
6935 #[allow(clippy::enum_variant_names)]
6936 enum GeneratedField {
6937 VersionDeltas,
6938 }
6939 impl<'de> serde::Deserialize<'de> for GeneratedField {
6940 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6941 where
6942 D: serde::Deserializer<'de>,
6943 {
6944 struct GeneratedVisitor;
6945
6946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6947 type Value = GeneratedField;
6948
6949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6950 write!(formatter, "expected one of: {:?}", &FIELDS)
6951 }
6952
6953 #[allow(unused_variables)]
6954 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6955 where
6956 E: serde::de::Error,
6957 {
6958 match value {
6959 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6960 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6961 }
6962 }
6963 }
6964 deserializer.deserialize_identifier(GeneratedVisitor)
6965 }
6966 }
6967 struct GeneratedVisitor;
6968 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6969 type Value = HummockVersionDeltas;
6970
6971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6972 formatter.write_str("struct hummock.HummockVersionDeltas")
6973 }
6974
6975 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
6976 where
6977 V: serde::de::MapAccess<'de>,
6978 {
6979 let mut version_deltas__ = None;
6980 while let Some(k) = map_.next_key()? {
6981 match k {
6982 GeneratedField::VersionDeltas => {
6983 if version_deltas__.is_some() {
6984 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6985 }
6986 version_deltas__ = Some(map_.next_value()?);
6987 }
6988 }
6989 }
6990 Ok(HummockVersionDeltas {
6991 version_deltas: version_deltas__.unwrap_or_default(),
6992 })
6993 }
6994 }
6995 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
6996 }
6997}
6998impl serde::Serialize for HummockVersionStats {
6999 #[allow(deprecated)]
7000 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7001 where
7002 S: serde::Serializer,
7003 {
7004 use serde::ser::SerializeStruct;
7005 let mut len = 0;
7006 if self.hummock_version_id != 0 {
7007 len += 1;
7008 }
7009 if !self.table_stats.is_empty() {
7010 len += 1;
7011 }
7012 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
7013 if self.hummock_version_id != 0 {
7014 #[allow(clippy::needless_borrow)]
7015 #[allow(clippy::needless_borrows_for_generic_args)]
7016 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
7017 }
7018 if !self.table_stats.is_empty() {
7019 struct_ser.serialize_field("tableStats", &self.table_stats)?;
7020 }
7021 struct_ser.end()
7022 }
7023}
7024impl<'de> serde::Deserialize<'de> for HummockVersionStats {
7025 #[allow(deprecated)]
7026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7027 where
7028 D: serde::Deserializer<'de>,
7029 {
7030 const FIELDS: &[&str] = &[
7031 "hummock_version_id",
7032 "hummockVersionId",
7033 "table_stats",
7034 "tableStats",
7035 ];
7036
7037 #[allow(clippy::enum_variant_names)]
7038 enum GeneratedField {
7039 HummockVersionId,
7040 TableStats,
7041 }
7042 impl<'de> serde::Deserialize<'de> for GeneratedField {
7043 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7044 where
7045 D: serde::Deserializer<'de>,
7046 {
7047 struct GeneratedVisitor;
7048
7049 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7050 type Value = GeneratedField;
7051
7052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7053 write!(formatter, "expected one of: {:?}", &FIELDS)
7054 }
7055
7056 #[allow(unused_variables)]
7057 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7058 where
7059 E: serde::de::Error,
7060 {
7061 match value {
7062 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
7063 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
7064 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7065 }
7066 }
7067 }
7068 deserializer.deserialize_identifier(GeneratedVisitor)
7069 }
7070 }
7071 struct GeneratedVisitor;
7072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7073 type Value = HummockVersionStats;
7074
7075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7076 formatter.write_str("struct hummock.HummockVersionStats")
7077 }
7078
7079 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
7080 where
7081 V: serde::de::MapAccess<'de>,
7082 {
7083 let mut hummock_version_id__ = None;
7084 let mut table_stats__ = None;
7085 while let Some(k) = map_.next_key()? {
7086 match k {
7087 GeneratedField::HummockVersionId => {
7088 if hummock_version_id__.is_some() {
7089 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
7090 }
7091 hummock_version_id__ =
7092 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7093 ;
7094 }
7095 GeneratedField::TableStats => {
7096 if table_stats__.is_some() {
7097 return Err(serde::de::Error::duplicate_field("tableStats"));
7098 }
7099 table_stats__ = Some(
7100 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7101 .into_iter().map(|(k,v)| (k.0, v)).collect()
7102 );
7103 }
7104 }
7105 }
7106 Ok(HummockVersionStats {
7107 hummock_version_id: hummock_version_id__.unwrap_or_default(),
7108 table_stats: table_stats__.unwrap_or_default(),
7109 })
7110 }
7111 }
7112 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
7113 }
7114}
7115impl serde::Serialize for InitMetadataForReplayRequest {
7116 #[allow(deprecated)]
7117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7118 where
7119 S: serde::Serializer,
7120 {
7121 use serde::ser::SerializeStruct;
7122 let mut len = 0;
7123 if !self.tables.is_empty() {
7124 len += 1;
7125 }
7126 if !self.compaction_groups.is_empty() {
7127 len += 1;
7128 }
7129 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
7130 if !self.tables.is_empty() {
7131 struct_ser.serialize_field("tables", &self.tables)?;
7132 }
7133 if !self.compaction_groups.is_empty() {
7134 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
7135 }
7136 struct_ser.end()
7137 }
7138}
7139impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
7140 #[allow(deprecated)]
7141 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7142 where
7143 D: serde::Deserializer<'de>,
7144 {
7145 const FIELDS: &[&str] = &[
7146 "tables",
7147 "compaction_groups",
7148 "compactionGroups",
7149 ];
7150
7151 #[allow(clippy::enum_variant_names)]
7152 enum GeneratedField {
7153 Tables,
7154 CompactionGroups,
7155 }
7156 impl<'de> serde::Deserialize<'de> for GeneratedField {
7157 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7158 where
7159 D: serde::Deserializer<'de>,
7160 {
7161 struct GeneratedVisitor;
7162
7163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7164 type Value = GeneratedField;
7165
7166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7167 write!(formatter, "expected one of: {:?}", &FIELDS)
7168 }
7169
7170 #[allow(unused_variables)]
7171 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7172 where
7173 E: serde::de::Error,
7174 {
7175 match value {
7176 "tables" => Ok(GeneratedField::Tables),
7177 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
7178 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7179 }
7180 }
7181 }
7182 deserializer.deserialize_identifier(GeneratedVisitor)
7183 }
7184 }
7185 struct GeneratedVisitor;
7186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7187 type Value = InitMetadataForReplayRequest;
7188
7189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7190 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
7191 }
7192
7193 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
7194 where
7195 V: serde::de::MapAccess<'de>,
7196 {
7197 let mut tables__ = None;
7198 let mut compaction_groups__ = None;
7199 while let Some(k) = map_.next_key()? {
7200 match k {
7201 GeneratedField::Tables => {
7202 if tables__.is_some() {
7203 return Err(serde::de::Error::duplicate_field("tables"));
7204 }
7205 tables__ = Some(map_.next_value()?);
7206 }
7207 GeneratedField::CompactionGroups => {
7208 if compaction_groups__.is_some() {
7209 return Err(serde::de::Error::duplicate_field("compactionGroups"));
7210 }
7211 compaction_groups__ = Some(map_.next_value()?);
7212 }
7213 }
7214 }
7215 Ok(InitMetadataForReplayRequest {
7216 tables: tables__.unwrap_or_default(),
7217 compaction_groups: compaction_groups__.unwrap_or_default(),
7218 })
7219 }
7220 }
7221 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
7222 }
7223}
7224impl serde::Serialize for InitMetadataForReplayResponse {
7225 #[allow(deprecated)]
7226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7227 where
7228 S: serde::Serializer,
7229 {
7230 use serde::ser::SerializeStruct;
7231 let len = 0;
7232 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
7233 struct_ser.end()
7234 }
7235}
7236impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
7237 #[allow(deprecated)]
7238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7239 where
7240 D: serde::Deserializer<'de>,
7241 {
7242 const FIELDS: &[&str] = &[
7243 ];
7244
7245 #[allow(clippy::enum_variant_names)]
7246 enum GeneratedField {
7247 }
7248 impl<'de> serde::Deserialize<'de> for GeneratedField {
7249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7250 where
7251 D: serde::Deserializer<'de>,
7252 {
7253 struct GeneratedVisitor;
7254
7255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7256 type Value = GeneratedField;
7257
7258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7259 write!(formatter, "expected one of: {:?}", &FIELDS)
7260 }
7261
7262 #[allow(unused_variables)]
7263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7264 where
7265 E: serde::de::Error,
7266 {
7267 Err(serde::de::Error::unknown_field(value, FIELDS))
7268 }
7269 }
7270 deserializer.deserialize_identifier(GeneratedVisitor)
7271 }
7272 }
7273 struct GeneratedVisitor;
7274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7275 type Value = InitMetadataForReplayResponse;
7276
7277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7278 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
7279 }
7280
7281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
7282 where
7283 V: serde::de::MapAccess<'de>,
7284 {
7285 while map_.next_key::<GeneratedField>()?.is_some() {
7286 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7287 }
7288 Ok(InitMetadataForReplayResponse {
7289 })
7290 }
7291 }
7292 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
7293 }
7294}
7295impl serde::Serialize for InputLevel {
7296 #[allow(deprecated)]
7297 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7298 where
7299 S: serde::Serializer,
7300 {
7301 use serde::ser::SerializeStruct;
7302 let mut len = 0;
7303 if self.level_idx != 0 {
7304 len += 1;
7305 }
7306 if self.level_type != 0 {
7307 len += 1;
7308 }
7309 if !self.table_infos.is_empty() {
7310 len += 1;
7311 }
7312 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
7313 if self.level_idx != 0 {
7314 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7315 }
7316 if self.level_type != 0 {
7317 let v = LevelType::try_from(self.level_type)
7318 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7319 struct_ser.serialize_field("levelType", &v)?;
7320 }
7321 if !self.table_infos.is_empty() {
7322 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7323 }
7324 struct_ser.end()
7325 }
7326}
7327impl<'de> serde::Deserialize<'de> for InputLevel {
7328 #[allow(deprecated)]
7329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7330 where
7331 D: serde::Deserializer<'de>,
7332 {
7333 const FIELDS: &[&str] = &[
7334 "level_idx",
7335 "levelIdx",
7336 "level_type",
7337 "levelType",
7338 "table_infos",
7339 "tableInfos",
7340 ];
7341
7342 #[allow(clippy::enum_variant_names)]
7343 enum GeneratedField {
7344 LevelIdx,
7345 LevelType,
7346 TableInfos,
7347 }
7348 impl<'de> serde::Deserialize<'de> for GeneratedField {
7349 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7350 where
7351 D: serde::Deserializer<'de>,
7352 {
7353 struct GeneratedVisitor;
7354
7355 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7356 type Value = GeneratedField;
7357
7358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7359 write!(formatter, "expected one of: {:?}", &FIELDS)
7360 }
7361
7362 #[allow(unused_variables)]
7363 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7364 where
7365 E: serde::de::Error,
7366 {
7367 match value {
7368 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7369 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
7370 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
7371 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7372 }
7373 }
7374 }
7375 deserializer.deserialize_identifier(GeneratedVisitor)
7376 }
7377 }
7378 struct GeneratedVisitor;
7379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7380 type Value = InputLevel;
7381
7382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7383 formatter.write_str("struct hummock.InputLevel")
7384 }
7385
7386 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
7387 where
7388 V: serde::de::MapAccess<'de>,
7389 {
7390 let mut level_idx__ = None;
7391 let mut level_type__ = None;
7392 let mut table_infos__ = None;
7393 while let Some(k) = map_.next_key()? {
7394 match k {
7395 GeneratedField::LevelIdx => {
7396 if level_idx__.is_some() {
7397 return Err(serde::de::Error::duplicate_field("levelIdx"));
7398 }
7399 level_idx__ =
7400 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7401 ;
7402 }
7403 GeneratedField::LevelType => {
7404 if level_type__.is_some() {
7405 return Err(serde::de::Error::duplicate_field("levelType"));
7406 }
7407 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
7408 }
7409 GeneratedField::TableInfos => {
7410 if table_infos__.is_some() {
7411 return Err(serde::de::Error::duplicate_field("tableInfos"));
7412 }
7413 table_infos__ = Some(map_.next_value()?);
7414 }
7415 }
7416 }
7417 Ok(InputLevel {
7418 level_idx: level_idx__.unwrap_or_default(),
7419 level_type: level_type__.unwrap_or_default(),
7420 table_infos: table_infos__.unwrap_or_default(),
7421 })
7422 }
7423 }
7424 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
7425 }
7426}
7427impl serde::Serialize for IntraLevelDelta {
7428 #[allow(deprecated)]
7429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7430 where
7431 S: serde::Serializer,
7432 {
7433 use serde::ser::SerializeStruct;
7434 let mut len = 0;
7435 if self.level_idx != 0 {
7436 len += 1;
7437 }
7438 if self.l0_sub_level_id != 0 {
7439 len += 1;
7440 }
7441 if !self.removed_table_ids.is_empty() {
7442 len += 1;
7443 }
7444 if !self.inserted_table_infos.is_empty() {
7445 len += 1;
7446 }
7447 if self.vnode_partition_count != 0 {
7448 len += 1;
7449 }
7450 if self.compaction_group_version_id != 0 {
7451 len += 1;
7452 }
7453 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
7454 if self.level_idx != 0 {
7455 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7456 }
7457 if self.l0_sub_level_id != 0 {
7458 #[allow(clippy::needless_borrow)]
7459 #[allow(clippy::needless_borrows_for_generic_args)]
7460 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
7461 }
7462 if !self.removed_table_ids.is_empty() {
7463 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7464 }
7465 if !self.inserted_table_infos.is_empty() {
7466 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
7467 }
7468 if self.vnode_partition_count != 0 {
7469 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7470 }
7471 if self.compaction_group_version_id != 0 {
7472 #[allow(clippy::needless_borrow)]
7473 #[allow(clippy::needless_borrows_for_generic_args)]
7474 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
7475 }
7476 struct_ser.end()
7477 }
7478}
7479impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
7480 #[allow(deprecated)]
7481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7482 where
7483 D: serde::Deserializer<'de>,
7484 {
7485 const FIELDS: &[&str] = &[
7486 "level_idx",
7487 "levelIdx",
7488 "l0_sub_level_id",
7489 "l0SubLevelId",
7490 "removed_table_ids",
7491 "removedTableIds",
7492 "inserted_table_infos",
7493 "insertedTableInfos",
7494 "vnode_partition_count",
7495 "vnodePartitionCount",
7496 "compaction_group_version_id",
7497 "compactionGroupVersionId",
7498 ];
7499
7500 #[allow(clippy::enum_variant_names)]
7501 enum GeneratedField {
7502 LevelIdx,
7503 L0SubLevelId,
7504 RemovedTableIds,
7505 InsertedTableInfos,
7506 VnodePartitionCount,
7507 CompactionGroupVersionId,
7508 }
7509 impl<'de> serde::Deserialize<'de> for GeneratedField {
7510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7511 where
7512 D: serde::Deserializer<'de>,
7513 {
7514 struct GeneratedVisitor;
7515
7516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7517 type Value = GeneratedField;
7518
7519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7520 write!(formatter, "expected one of: {:?}", &FIELDS)
7521 }
7522
7523 #[allow(unused_variables)]
7524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7525 where
7526 E: serde::de::Error,
7527 {
7528 match value {
7529 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7530 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
7531 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7532 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
7533 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7534 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
7535 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7536 }
7537 }
7538 }
7539 deserializer.deserialize_identifier(GeneratedVisitor)
7540 }
7541 }
7542 struct GeneratedVisitor;
7543 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7544 type Value = IntraLevelDelta;
7545
7546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7547 formatter.write_str("struct hummock.IntraLevelDelta")
7548 }
7549
7550 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
7551 where
7552 V: serde::de::MapAccess<'de>,
7553 {
7554 let mut level_idx__ = None;
7555 let mut l0_sub_level_id__ = None;
7556 let mut removed_table_ids__ = None;
7557 let mut inserted_table_infos__ = None;
7558 let mut vnode_partition_count__ = None;
7559 let mut compaction_group_version_id__ = None;
7560 while let Some(k) = map_.next_key()? {
7561 match k {
7562 GeneratedField::LevelIdx => {
7563 if level_idx__.is_some() {
7564 return Err(serde::de::Error::duplicate_field("levelIdx"));
7565 }
7566 level_idx__ =
7567 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7568 ;
7569 }
7570 GeneratedField::L0SubLevelId => {
7571 if l0_sub_level_id__.is_some() {
7572 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
7573 }
7574 l0_sub_level_id__ =
7575 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7576 ;
7577 }
7578 GeneratedField::RemovedTableIds => {
7579 if removed_table_ids__.is_some() {
7580 return Err(serde::de::Error::duplicate_field("removedTableIds"));
7581 }
7582 removed_table_ids__ =
7583 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7584 .into_iter().map(|x| x.0).collect())
7585 ;
7586 }
7587 GeneratedField::InsertedTableInfos => {
7588 if inserted_table_infos__.is_some() {
7589 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
7590 }
7591 inserted_table_infos__ = Some(map_.next_value()?);
7592 }
7593 GeneratedField::VnodePartitionCount => {
7594 if vnode_partition_count__.is_some() {
7595 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7596 }
7597 vnode_partition_count__ =
7598 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7599 ;
7600 }
7601 GeneratedField::CompactionGroupVersionId => {
7602 if compaction_group_version_id__.is_some() {
7603 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
7604 }
7605 compaction_group_version_id__ =
7606 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7607 ;
7608 }
7609 }
7610 }
7611 Ok(IntraLevelDelta {
7612 level_idx: level_idx__.unwrap_or_default(),
7613 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
7614 removed_table_ids: removed_table_ids__.unwrap_or_default(),
7615 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
7616 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7617 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
7618 })
7619 }
7620 }
7621 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
7622 }
7623}
7624impl serde::Serialize for KeyRange {
7625 #[allow(deprecated)]
7626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7627 where
7628 S: serde::Serializer,
7629 {
7630 use serde::ser::SerializeStruct;
7631 let mut len = 0;
7632 if !self.left.is_empty() {
7633 len += 1;
7634 }
7635 if !self.right.is_empty() {
7636 len += 1;
7637 }
7638 if self.right_exclusive {
7639 len += 1;
7640 }
7641 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
7642 if !self.left.is_empty() {
7643 #[allow(clippy::needless_borrow)]
7644 #[allow(clippy::needless_borrows_for_generic_args)]
7645 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
7646 }
7647 if !self.right.is_empty() {
7648 #[allow(clippy::needless_borrow)]
7649 #[allow(clippy::needless_borrows_for_generic_args)]
7650 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
7651 }
7652 if self.right_exclusive {
7653 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
7654 }
7655 struct_ser.end()
7656 }
7657}
7658impl<'de> serde::Deserialize<'de> for KeyRange {
7659 #[allow(deprecated)]
7660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7661 where
7662 D: serde::Deserializer<'de>,
7663 {
7664 const FIELDS: &[&str] = &[
7665 "left",
7666 "right",
7667 "right_exclusive",
7668 "rightExclusive",
7669 ];
7670
7671 #[allow(clippy::enum_variant_names)]
7672 enum GeneratedField {
7673 Left,
7674 Right,
7675 RightExclusive,
7676 }
7677 impl<'de> serde::Deserialize<'de> for GeneratedField {
7678 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7679 where
7680 D: serde::Deserializer<'de>,
7681 {
7682 struct GeneratedVisitor;
7683
7684 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7685 type Value = GeneratedField;
7686
7687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7688 write!(formatter, "expected one of: {:?}", &FIELDS)
7689 }
7690
7691 #[allow(unused_variables)]
7692 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7693 where
7694 E: serde::de::Error,
7695 {
7696 match value {
7697 "left" => Ok(GeneratedField::Left),
7698 "right" => Ok(GeneratedField::Right),
7699 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
7700 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7701 }
7702 }
7703 }
7704 deserializer.deserialize_identifier(GeneratedVisitor)
7705 }
7706 }
7707 struct GeneratedVisitor;
7708 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7709 type Value = KeyRange;
7710
7711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7712 formatter.write_str("struct hummock.KeyRange")
7713 }
7714
7715 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
7716 where
7717 V: serde::de::MapAccess<'de>,
7718 {
7719 let mut left__ = None;
7720 let mut right__ = None;
7721 let mut right_exclusive__ = None;
7722 while let Some(k) = map_.next_key()? {
7723 match k {
7724 GeneratedField::Left => {
7725 if left__.is_some() {
7726 return Err(serde::de::Error::duplicate_field("left"));
7727 }
7728 left__ =
7729 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7730 ;
7731 }
7732 GeneratedField::Right => {
7733 if right__.is_some() {
7734 return Err(serde::de::Error::duplicate_field("right"));
7735 }
7736 right__ =
7737 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7738 ;
7739 }
7740 GeneratedField::RightExclusive => {
7741 if right_exclusive__.is_some() {
7742 return Err(serde::de::Error::duplicate_field("rightExclusive"));
7743 }
7744 right_exclusive__ = Some(map_.next_value()?);
7745 }
7746 }
7747 }
7748 Ok(KeyRange {
7749 left: left__.unwrap_or_default(),
7750 right: right__.unwrap_or_default(),
7751 right_exclusive: right_exclusive__.unwrap_or_default(),
7752 })
7753 }
7754 }
7755 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
7756 }
7757}
7758impl serde::Serialize for Level {
7759 #[allow(deprecated)]
7760 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7761 where
7762 S: serde::Serializer,
7763 {
7764 use serde::ser::SerializeStruct;
7765 let mut len = 0;
7766 if self.level_idx != 0 {
7767 len += 1;
7768 }
7769 if self.level_type != 0 {
7770 len += 1;
7771 }
7772 if !self.table_infos.is_empty() {
7773 len += 1;
7774 }
7775 if self.total_file_size != 0 {
7776 len += 1;
7777 }
7778 if self.sub_level_id != 0 {
7779 len += 1;
7780 }
7781 if self.uncompressed_file_size != 0 {
7782 len += 1;
7783 }
7784 if self.vnode_partition_count != 0 {
7785 len += 1;
7786 }
7787 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
7788 if self.level_idx != 0 {
7789 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7790 }
7791 if self.level_type != 0 {
7792 let v = LevelType::try_from(self.level_type)
7793 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7794 struct_ser.serialize_field("levelType", &v)?;
7795 }
7796 if !self.table_infos.is_empty() {
7797 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7798 }
7799 if self.total_file_size != 0 {
7800 #[allow(clippy::needless_borrow)]
7801 #[allow(clippy::needless_borrows_for_generic_args)]
7802 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7803 }
7804 if self.sub_level_id != 0 {
7805 #[allow(clippy::needless_borrow)]
7806 #[allow(clippy::needless_borrows_for_generic_args)]
7807 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
7808 }
7809 if self.uncompressed_file_size != 0 {
7810 #[allow(clippy::needless_borrow)]
7811 #[allow(clippy::needless_borrows_for_generic_args)]
7812 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
7813 }
7814 if self.vnode_partition_count != 0 {
7815 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7816 }
7817 struct_ser.end()
7818 }
7819}
7820impl<'de> serde::Deserialize<'de> for Level {
7821 #[allow(deprecated)]
7822 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7823 where
7824 D: serde::Deserializer<'de>,
7825 {
7826 const FIELDS: &[&str] = &[
7827 "level_idx",
7828 "levelIdx",
7829 "level_type",
7830 "levelType",
7831 "table_infos",
7832 "tableInfos",
7833 "total_file_size",
7834 "totalFileSize",
7835 "sub_level_id",
7836 "subLevelId",
7837 "uncompressed_file_size",
7838 "uncompressedFileSize",
7839 "vnode_partition_count",
7840 "vnodePartitionCount",
7841 ];
7842
7843 #[allow(clippy::enum_variant_names)]
7844 enum GeneratedField {
7845 LevelIdx,
7846 LevelType,
7847 TableInfos,
7848 TotalFileSize,
7849 SubLevelId,
7850 UncompressedFileSize,
7851 VnodePartitionCount,
7852 }
7853 impl<'de> serde::Deserialize<'de> for GeneratedField {
7854 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7855 where
7856 D: serde::Deserializer<'de>,
7857 {
7858 struct GeneratedVisitor;
7859
7860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7861 type Value = GeneratedField;
7862
7863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7864 write!(formatter, "expected one of: {:?}", &FIELDS)
7865 }
7866
7867 #[allow(unused_variables)]
7868 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7869 where
7870 E: serde::de::Error,
7871 {
7872 match value {
7873 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7874 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
7875 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
7876 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7877 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
7878 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
7879 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7880 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7881 }
7882 }
7883 }
7884 deserializer.deserialize_identifier(GeneratedVisitor)
7885 }
7886 }
7887 struct GeneratedVisitor;
7888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7889 type Value = Level;
7890
7891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7892 formatter.write_str("struct hummock.Level")
7893 }
7894
7895 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
7896 where
7897 V: serde::de::MapAccess<'de>,
7898 {
7899 let mut level_idx__ = None;
7900 let mut level_type__ = None;
7901 let mut table_infos__ = None;
7902 let mut total_file_size__ = None;
7903 let mut sub_level_id__ = None;
7904 let mut uncompressed_file_size__ = None;
7905 let mut vnode_partition_count__ = None;
7906 while let Some(k) = map_.next_key()? {
7907 match k {
7908 GeneratedField::LevelIdx => {
7909 if level_idx__.is_some() {
7910 return Err(serde::de::Error::duplicate_field("levelIdx"));
7911 }
7912 level_idx__ =
7913 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7914 ;
7915 }
7916 GeneratedField::LevelType => {
7917 if level_type__.is_some() {
7918 return Err(serde::de::Error::duplicate_field("levelType"));
7919 }
7920 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
7921 }
7922 GeneratedField::TableInfos => {
7923 if table_infos__.is_some() {
7924 return Err(serde::de::Error::duplicate_field("tableInfos"));
7925 }
7926 table_infos__ = Some(map_.next_value()?);
7927 }
7928 GeneratedField::TotalFileSize => {
7929 if total_file_size__.is_some() {
7930 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7931 }
7932 total_file_size__ =
7933 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7934 ;
7935 }
7936 GeneratedField::SubLevelId => {
7937 if sub_level_id__.is_some() {
7938 return Err(serde::de::Error::duplicate_field("subLevelId"));
7939 }
7940 sub_level_id__ =
7941 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7942 ;
7943 }
7944 GeneratedField::UncompressedFileSize => {
7945 if uncompressed_file_size__.is_some() {
7946 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
7947 }
7948 uncompressed_file_size__ =
7949 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7950 ;
7951 }
7952 GeneratedField::VnodePartitionCount => {
7953 if vnode_partition_count__.is_some() {
7954 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7955 }
7956 vnode_partition_count__ =
7957 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7958 ;
7959 }
7960 }
7961 }
7962 Ok(Level {
7963 level_idx: level_idx__.unwrap_or_default(),
7964 level_type: level_type__.unwrap_or_default(),
7965 table_infos: table_infos__.unwrap_or_default(),
7966 total_file_size: total_file_size__.unwrap_or_default(),
7967 sub_level_id: sub_level_id__.unwrap_or_default(),
7968 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
7969 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7970 })
7971 }
7972 }
7973 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
7974 }
7975}
7976impl serde::Serialize for LevelHandler {
7977 #[allow(deprecated)]
7978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7979 where
7980 S: serde::Serializer,
7981 {
7982 use serde::ser::SerializeStruct;
7983 let mut len = 0;
7984 if self.level != 0 {
7985 len += 1;
7986 }
7987 if !self.tasks.is_empty() {
7988 len += 1;
7989 }
7990 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
7991 if self.level != 0 {
7992 struct_ser.serialize_field("level", &self.level)?;
7993 }
7994 if !self.tasks.is_empty() {
7995 struct_ser.serialize_field("tasks", &self.tasks)?;
7996 }
7997 struct_ser.end()
7998 }
7999}
8000impl<'de> serde::Deserialize<'de> for LevelHandler {
8001 #[allow(deprecated)]
8002 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8003 where
8004 D: serde::Deserializer<'de>,
8005 {
8006 const FIELDS: &[&str] = &[
8007 "level",
8008 "tasks",
8009 ];
8010
8011 #[allow(clippy::enum_variant_names)]
8012 enum GeneratedField {
8013 Level,
8014 Tasks,
8015 }
8016 impl<'de> serde::Deserialize<'de> for GeneratedField {
8017 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8018 where
8019 D: serde::Deserializer<'de>,
8020 {
8021 struct GeneratedVisitor;
8022
8023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8024 type Value = GeneratedField;
8025
8026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8027 write!(formatter, "expected one of: {:?}", &FIELDS)
8028 }
8029
8030 #[allow(unused_variables)]
8031 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8032 where
8033 E: serde::de::Error,
8034 {
8035 match value {
8036 "level" => Ok(GeneratedField::Level),
8037 "tasks" => Ok(GeneratedField::Tasks),
8038 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8039 }
8040 }
8041 }
8042 deserializer.deserialize_identifier(GeneratedVisitor)
8043 }
8044 }
8045 struct GeneratedVisitor;
8046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8047 type Value = LevelHandler;
8048
8049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8050 formatter.write_str("struct hummock.LevelHandler")
8051 }
8052
8053 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
8054 where
8055 V: serde::de::MapAccess<'de>,
8056 {
8057 let mut level__ = None;
8058 let mut tasks__ = None;
8059 while let Some(k) = map_.next_key()? {
8060 match k {
8061 GeneratedField::Level => {
8062 if level__.is_some() {
8063 return Err(serde::de::Error::duplicate_field("level"));
8064 }
8065 level__ =
8066 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8067 ;
8068 }
8069 GeneratedField::Tasks => {
8070 if tasks__.is_some() {
8071 return Err(serde::de::Error::duplicate_field("tasks"));
8072 }
8073 tasks__ = Some(map_.next_value()?);
8074 }
8075 }
8076 }
8077 Ok(LevelHandler {
8078 level: level__.unwrap_or_default(),
8079 tasks: tasks__.unwrap_or_default(),
8080 })
8081 }
8082 }
8083 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
8084 }
8085}
8086impl serde::Serialize for level_handler::RunningCompactTask {
8087 #[allow(deprecated)]
8088 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8089 where
8090 S: serde::Serializer,
8091 {
8092 use serde::ser::SerializeStruct;
8093 let mut len = 0;
8094 if self.task_id != 0 {
8095 len += 1;
8096 }
8097 if !self.ssts.is_empty() {
8098 len += 1;
8099 }
8100 if self.total_file_size != 0 {
8101 len += 1;
8102 }
8103 if self.target_level != 0 {
8104 len += 1;
8105 }
8106 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
8107 if self.task_id != 0 {
8108 #[allow(clippy::needless_borrow)]
8109 #[allow(clippy::needless_borrows_for_generic_args)]
8110 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
8111 }
8112 if !self.ssts.is_empty() {
8113 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8114 }
8115 if self.total_file_size != 0 {
8116 #[allow(clippy::needless_borrow)]
8117 #[allow(clippy::needless_borrows_for_generic_args)]
8118 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8119 }
8120 if self.target_level != 0 {
8121 struct_ser.serialize_field("targetLevel", &self.target_level)?;
8122 }
8123 struct_ser.end()
8124 }
8125}
8126impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
8127 #[allow(deprecated)]
8128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8129 where
8130 D: serde::Deserializer<'de>,
8131 {
8132 const FIELDS: &[&str] = &[
8133 "task_id",
8134 "taskId",
8135 "ssts",
8136 "total_file_size",
8137 "totalFileSize",
8138 "target_level",
8139 "targetLevel",
8140 ];
8141
8142 #[allow(clippy::enum_variant_names)]
8143 enum GeneratedField {
8144 TaskId,
8145 Ssts,
8146 TotalFileSize,
8147 TargetLevel,
8148 }
8149 impl<'de> serde::Deserialize<'de> for GeneratedField {
8150 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8151 where
8152 D: serde::Deserializer<'de>,
8153 {
8154 struct GeneratedVisitor;
8155
8156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8157 type Value = GeneratedField;
8158
8159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8160 write!(formatter, "expected one of: {:?}", &FIELDS)
8161 }
8162
8163 #[allow(unused_variables)]
8164 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8165 where
8166 E: serde::de::Error,
8167 {
8168 match value {
8169 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8170 "ssts" => Ok(GeneratedField::Ssts),
8171 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8172 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
8173 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8174 }
8175 }
8176 }
8177 deserializer.deserialize_identifier(GeneratedVisitor)
8178 }
8179 }
8180 struct GeneratedVisitor;
8181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8182 type Value = level_handler::RunningCompactTask;
8183
8184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8185 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
8186 }
8187
8188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
8189 where
8190 V: serde::de::MapAccess<'de>,
8191 {
8192 let mut task_id__ = None;
8193 let mut ssts__ = None;
8194 let mut total_file_size__ = None;
8195 let mut target_level__ = None;
8196 while let Some(k) = map_.next_key()? {
8197 match k {
8198 GeneratedField::TaskId => {
8199 if task_id__.is_some() {
8200 return Err(serde::de::Error::duplicate_field("taskId"));
8201 }
8202 task_id__ =
8203 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8204 ;
8205 }
8206 GeneratedField::Ssts => {
8207 if ssts__.is_some() {
8208 return Err(serde::de::Error::duplicate_field("ssts"));
8209 }
8210 ssts__ =
8211 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8212 .into_iter().map(|x| x.0).collect())
8213 ;
8214 }
8215 GeneratedField::TotalFileSize => {
8216 if total_file_size__.is_some() {
8217 return Err(serde::de::Error::duplicate_field("totalFileSize"));
8218 }
8219 total_file_size__ =
8220 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8221 ;
8222 }
8223 GeneratedField::TargetLevel => {
8224 if target_level__.is_some() {
8225 return Err(serde::de::Error::duplicate_field("targetLevel"));
8226 }
8227 target_level__ =
8228 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8229 ;
8230 }
8231 }
8232 }
8233 Ok(level_handler::RunningCompactTask {
8234 task_id: task_id__.unwrap_or_default(),
8235 ssts: ssts__.unwrap_or_default(),
8236 total_file_size: total_file_size__.unwrap_or_default(),
8237 target_level: target_level__.unwrap_or_default(),
8238 })
8239 }
8240 }
8241 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
8242 }
8243}
8244impl serde::Serialize for LevelType {
8245 #[allow(deprecated)]
8246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8247 where
8248 S: serde::Serializer,
8249 {
8250 let variant = match self {
8251 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
8252 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
8253 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
8254 };
8255 serializer.serialize_str(variant)
8256 }
8257}
8258impl<'de> serde::Deserialize<'de> for LevelType {
8259 #[allow(deprecated)]
8260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8261 where
8262 D: serde::Deserializer<'de>,
8263 {
8264 const FIELDS: &[&str] = &[
8265 "LEVEL_TYPE_UNSPECIFIED",
8266 "LEVEL_TYPE_NONOVERLAPPING",
8267 "LEVEL_TYPE_OVERLAPPING",
8268 ];
8269
8270 struct GeneratedVisitor;
8271
8272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8273 type Value = LevelType;
8274
8275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8276 write!(formatter, "expected one of: {:?}", &FIELDS)
8277 }
8278
8279 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8280 where
8281 E: serde::de::Error,
8282 {
8283 i32::try_from(v)
8284 .ok()
8285 .and_then(|x| x.try_into().ok())
8286 .ok_or_else(|| {
8287 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8288 })
8289 }
8290
8291 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8292 where
8293 E: serde::de::Error,
8294 {
8295 i32::try_from(v)
8296 .ok()
8297 .and_then(|x| x.try_into().ok())
8298 .ok_or_else(|| {
8299 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8300 })
8301 }
8302
8303 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8304 where
8305 E: serde::de::Error,
8306 {
8307 match value {
8308 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
8309 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
8310 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
8311 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8312 }
8313 }
8314 }
8315 deserializer.deserialize_any(GeneratedVisitor)
8316 }
8317}
8318impl serde::Serialize for ListActiveWriteLimitRequest {
8319 #[allow(deprecated)]
8320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8321 where
8322 S: serde::Serializer,
8323 {
8324 use serde::ser::SerializeStruct;
8325 let len = 0;
8326 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
8327 struct_ser.end()
8328 }
8329}
8330impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
8331 #[allow(deprecated)]
8332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8333 where
8334 D: serde::Deserializer<'de>,
8335 {
8336 const FIELDS: &[&str] = &[
8337 ];
8338
8339 #[allow(clippy::enum_variant_names)]
8340 enum GeneratedField {
8341 }
8342 impl<'de> serde::Deserialize<'de> for GeneratedField {
8343 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8344 where
8345 D: serde::Deserializer<'de>,
8346 {
8347 struct GeneratedVisitor;
8348
8349 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8350 type Value = GeneratedField;
8351
8352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8353 write!(formatter, "expected one of: {:?}", &FIELDS)
8354 }
8355
8356 #[allow(unused_variables)]
8357 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8358 where
8359 E: serde::de::Error,
8360 {
8361 Err(serde::de::Error::unknown_field(value, FIELDS))
8362 }
8363 }
8364 deserializer.deserialize_identifier(GeneratedVisitor)
8365 }
8366 }
8367 struct GeneratedVisitor;
8368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8369 type Value = ListActiveWriteLimitRequest;
8370
8371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8372 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
8373 }
8374
8375 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
8376 where
8377 V: serde::de::MapAccess<'de>,
8378 {
8379 while map_.next_key::<GeneratedField>()?.is_some() {
8380 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8381 }
8382 Ok(ListActiveWriteLimitRequest {
8383 })
8384 }
8385 }
8386 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
8387 }
8388}
8389impl serde::Serialize for ListActiveWriteLimitResponse {
8390 #[allow(deprecated)]
8391 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8392 where
8393 S: serde::Serializer,
8394 {
8395 use serde::ser::SerializeStruct;
8396 let mut len = 0;
8397 if !self.write_limits.is_empty() {
8398 len += 1;
8399 }
8400 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
8401 if !self.write_limits.is_empty() {
8402 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
8403 }
8404 struct_ser.end()
8405 }
8406}
8407impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
8408 #[allow(deprecated)]
8409 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8410 where
8411 D: serde::Deserializer<'de>,
8412 {
8413 const FIELDS: &[&str] = &[
8414 "write_limits",
8415 "writeLimits",
8416 ];
8417
8418 #[allow(clippy::enum_variant_names)]
8419 enum GeneratedField {
8420 WriteLimits,
8421 }
8422 impl<'de> serde::Deserialize<'de> for GeneratedField {
8423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8424 where
8425 D: serde::Deserializer<'de>,
8426 {
8427 struct GeneratedVisitor;
8428
8429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8430 type Value = GeneratedField;
8431
8432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8433 write!(formatter, "expected one of: {:?}", &FIELDS)
8434 }
8435
8436 #[allow(unused_variables)]
8437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8438 where
8439 E: serde::de::Error,
8440 {
8441 match value {
8442 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
8443 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8444 }
8445 }
8446 }
8447 deserializer.deserialize_identifier(GeneratedVisitor)
8448 }
8449 }
8450 struct GeneratedVisitor;
8451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8452 type Value = ListActiveWriteLimitResponse;
8453
8454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8455 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
8456 }
8457
8458 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
8459 where
8460 V: serde::de::MapAccess<'de>,
8461 {
8462 let mut write_limits__ = None;
8463 while let Some(k) = map_.next_key()? {
8464 match k {
8465 GeneratedField::WriteLimits => {
8466 if write_limits__.is_some() {
8467 return Err(serde::de::Error::duplicate_field("writeLimits"));
8468 }
8469 write_limits__ = Some(
8470 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
8471 .into_iter().map(|(k,v)| (k.0, v)).collect()
8472 );
8473 }
8474 }
8475 }
8476 Ok(ListActiveWriteLimitResponse {
8477 write_limits: write_limits__.unwrap_or_default(),
8478 })
8479 }
8480 }
8481 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
8482 }
8483}
8484impl serde::Serialize for ListBranchedObjectRequest {
8485 #[allow(deprecated)]
8486 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8487 where
8488 S: serde::Serializer,
8489 {
8490 use serde::ser::SerializeStruct;
8491 let len = 0;
8492 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
8493 struct_ser.end()
8494 }
8495}
8496impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
8497 #[allow(deprecated)]
8498 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8499 where
8500 D: serde::Deserializer<'de>,
8501 {
8502 const FIELDS: &[&str] = &[
8503 ];
8504
8505 #[allow(clippy::enum_variant_names)]
8506 enum GeneratedField {
8507 }
8508 impl<'de> serde::Deserialize<'de> for GeneratedField {
8509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8510 where
8511 D: serde::Deserializer<'de>,
8512 {
8513 struct GeneratedVisitor;
8514
8515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8516 type Value = GeneratedField;
8517
8518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8519 write!(formatter, "expected one of: {:?}", &FIELDS)
8520 }
8521
8522 #[allow(unused_variables)]
8523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8524 where
8525 E: serde::de::Error,
8526 {
8527 Err(serde::de::Error::unknown_field(value, FIELDS))
8528 }
8529 }
8530 deserializer.deserialize_identifier(GeneratedVisitor)
8531 }
8532 }
8533 struct GeneratedVisitor;
8534 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8535 type Value = ListBranchedObjectRequest;
8536
8537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8538 formatter.write_str("struct hummock.ListBranchedObjectRequest")
8539 }
8540
8541 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
8542 where
8543 V: serde::de::MapAccess<'de>,
8544 {
8545 while map_.next_key::<GeneratedField>()?.is_some() {
8546 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8547 }
8548 Ok(ListBranchedObjectRequest {
8549 })
8550 }
8551 }
8552 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
8553 }
8554}
8555impl serde::Serialize for ListBranchedObjectResponse {
8556 #[allow(deprecated)]
8557 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8558 where
8559 S: serde::Serializer,
8560 {
8561 use serde::ser::SerializeStruct;
8562 let mut len = 0;
8563 if !self.branched_objects.is_empty() {
8564 len += 1;
8565 }
8566 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
8567 if !self.branched_objects.is_empty() {
8568 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
8569 }
8570 struct_ser.end()
8571 }
8572}
8573impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
8574 #[allow(deprecated)]
8575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8576 where
8577 D: serde::Deserializer<'de>,
8578 {
8579 const FIELDS: &[&str] = &[
8580 "branched_objects",
8581 "branchedObjects",
8582 ];
8583
8584 #[allow(clippy::enum_variant_names)]
8585 enum GeneratedField {
8586 BranchedObjects,
8587 }
8588 impl<'de> serde::Deserialize<'de> for GeneratedField {
8589 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8590 where
8591 D: serde::Deserializer<'de>,
8592 {
8593 struct GeneratedVisitor;
8594
8595 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8596 type Value = GeneratedField;
8597
8598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8599 write!(formatter, "expected one of: {:?}", &FIELDS)
8600 }
8601
8602 #[allow(unused_variables)]
8603 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8604 where
8605 E: serde::de::Error,
8606 {
8607 match value {
8608 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
8609 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8610 }
8611 }
8612 }
8613 deserializer.deserialize_identifier(GeneratedVisitor)
8614 }
8615 }
8616 struct GeneratedVisitor;
8617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8618 type Value = ListBranchedObjectResponse;
8619
8620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8621 formatter.write_str("struct hummock.ListBranchedObjectResponse")
8622 }
8623
8624 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
8625 where
8626 V: serde::de::MapAccess<'de>,
8627 {
8628 let mut branched_objects__ = None;
8629 while let Some(k) = map_.next_key()? {
8630 match k {
8631 GeneratedField::BranchedObjects => {
8632 if branched_objects__.is_some() {
8633 return Err(serde::de::Error::duplicate_field("branchedObjects"));
8634 }
8635 branched_objects__ = Some(map_.next_value()?);
8636 }
8637 }
8638 }
8639 Ok(ListBranchedObjectResponse {
8640 branched_objects: branched_objects__.unwrap_or_default(),
8641 })
8642 }
8643 }
8644 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
8645 }
8646}
8647impl serde::Serialize for ListCompactTaskAssignmentRequest {
8648 #[allow(deprecated)]
8649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8650 where
8651 S: serde::Serializer,
8652 {
8653 use serde::ser::SerializeStruct;
8654 let len = 0;
8655 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
8656 struct_ser.end()
8657 }
8658}
8659impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
8660 #[allow(deprecated)]
8661 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8662 where
8663 D: serde::Deserializer<'de>,
8664 {
8665 const FIELDS: &[&str] = &[
8666 ];
8667
8668 #[allow(clippy::enum_variant_names)]
8669 enum GeneratedField {
8670 }
8671 impl<'de> serde::Deserialize<'de> for GeneratedField {
8672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8673 where
8674 D: serde::Deserializer<'de>,
8675 {
8676 struct GeneratedVisitor;
8677
8678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8679 type Value = GeneratedField;
8680
8681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8682 write!(formatter, "expected one of: {:?}", &FIELDS)
8683 }
8684
8685 #[allow(unused_variables)]
8686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8687 where
8688 E: serde::de::Error,
8689 {
8690 Err(serde::de::Error::unknown_field(value, FIELDS))
8691 }
8692 }
8693 deserializer.deserialize_identifier(GeneratedVisitor)
8694 }
8695 }
8696 struct GeneratedVisitor;
8697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8698 type Value = ListCompactTaskAssignmentRequest;
8699
8700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8701 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
8702 }
8703
8704 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
8705 where
8706 V: serde::de::MapAccess<'de>,
8707 {
8708 while map_.next_key::<GeneratedField>()?.is_some() {
8709 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8710 }
8711 Ok(ListCompactTaskAssignmentRequest {
8712 })
8713 }
8714 }
8715 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
8716 }
8717}
8718impl serde::Serialize for ListCompactTaskAssignmentResponse {
8719 #[allow(deprecated)]
8720 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8721 where
8722 S: serde::Serializer,
8723 {
8724 use serde::ser::SerializeStruct;
8725 let mut len = 0;
8726 if !self.task_assignment.is_empty() {
8727 len += 1;
8728 }
8729 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
8730 if !self.task_assignment.is_empty() {
8731 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
8732 }
8733 struct_ser.end()
8734 }
8735}
8736impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
8737 #[allow(deprecated)]
8738 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8739 where
8740 D: serde::Deserializer<'de>,
8741 {
8742 const FIELDS: &[&str] = &[
8743 "task_assignment",
8744 "taskAssignment",
8745 ];
8746
8747 #[allow(clippy::enum_variant_names)]
8748 enum GeneratedField {
8749 TaskAssignment,
8750 }
8751 impl<'de> serde::Deserialize<'de> for GeneratedField {
8752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8753 where
8754 D: serde::Deserializer<'de>,
8755 {
8756 struct GeneratedVisitor;
8757
8758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8759 type Value = GeneratedField;
8760
8761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8762 write!(formatter, "expected one of: {:?}", &FIELDS)
8763 }
8764
8765 #[allow(unused_variables)]
8766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8767 where
8768 E: serde::de::Error,
8769 {
8770 match value {
8771 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
8772 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8773 }
8774 }
8775 }
8776 deserializer.deserialize_identifier(GeneratedVisitor)
8777 }
8778 }
8779 struct GeneratedVisitor;
8780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8781 type Value = ListCompactTaskAssignmentResponse;
8782
8783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8784 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
8785 }
8786
8787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
8788 where
8789 V: serde::de::MapAccess<'de>,
8790 {
8791 let mut task_assignment__ = None;
8792 while let Some(k) = map_.next_key()? {
8793 match k {
8794 GeneratedField::TaskAssignment => {
8795 if task_assignment__.is_some() {
8796 return Err(serde::de::Error::duplicate_field("taskAssignment"));
8797 }
8798 task_assignment__ = Some(map_.next_value()?);
8799 }
8800 }
8801 }
8802 Ok(ListCompactTaskAssignmentResponse {
8803 task_assignment: task_assignment__.unwrap_or_default(),
8804 })
8805 }
8806 }
8807 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
8808 }
8809}
8810impl serde::Serialize for ListCompactTaskProgressRequest {
8811 #[allow(deprecated)]
8812 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8813 where
8814 S: serde::Serializer,
8815 {
8816 use serde::ser::SerializeStruct;
8817 let len = 0;
8818 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
8819 struct_ser.end()
8820 }
8821}
8822impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
8823 #[allow(deprecated)]
8824 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8825 where
8826 D: serde::Deserializer<'de>,
8827 {
8828 const FIELDS: &[&str] = &[
8829 ];
8830
8831 #[allow(clippy::enum_variant_names)]
8832 enum GeneratedField {
8833 }
8834 impl<'de> serde::Deserialize<'de> for GeneratedField {
8835 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8836 where
8837 D: serde::Deserializer<'de>,
8838 {
8839 struct GeneratedVisitor;
8840
8841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8842 type Value = GeneratedField;
8843
8844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8845 write!(formatter, "expected one of: {:?}", &FIELDS)
8846 }
8847
8848 #[allow(unused_variables)]
8849 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8850 where
8851 E: serde::de::Error,
8852 {
8853 Err(serde::de::Error::unknown_field(value, FIELDS))
8854 }
8855 }
8856 deserializer.deserialize_identifier(GeneratedVisitor)
8857 }
8858 }
8859 struct GeneratedVisitor;
8860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8861 type Value = ListCompactTaskProgressRequest;
8862
8863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8864 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
8865 }
8866
8867 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
8868 where
8869 V: serde::de::MapAccess<'de>,
8870 {
8871 while map_.next_key::<GeneratedField>()?.is_some() {
8872 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8873 }
8874 Ok(ListCompactTaskProgressRequest {
8875 })
8876 }
8877 }
8878 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
8879 }
8880}
8881impl serde::Serialize for ListCompactTaskProgressResponse {
8882 #[allow(deprecated)]
8883 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8884 where
8885 S: serde::Serializer,
8886 {
8887 use serde::ser::SerializeStruct;
8888 let mut len = 0;
8889 if !self.task_progress.is_empty() {
8890 len += 1;
8891 }
8892 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
8893 if !self.task_progress.is_empty() {
8894 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
8895 }
8896 struct_ser.end()
8897 }
8898}
8899impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
8900 #[allow(deprecated)]
8901 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8902 where
8903 D: serde::Deserializer<'de>,
8904 {
8905 const FIELDS: &[&str] = &[
8906 "task_progress",
8907 "taskProgress",
8908 ];
8909
8910 #[allow(clippy::enum_variant_names)]
8911 enum GeneratedField {
8912 TaskProgress,
8913 }
8914 impl<'de> serde::Deserialize<'de> for GeneratedField {
8915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8916 where
8917 D: serde::Deserializer<'de>,
8918 {
8919 struct GeneratedVisitor;
8920
8921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8922 type Value = GeneratedField;
8923
8924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8925 write!(formatter, "expected one of: {:?}", &FIELDS)
8926 }
8927
8928 #[allow(unused_variables)]
8929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8930 where
8931 E: serde::de::Error,
8932 {
8933 match value {
8934 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
8935 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8936 }
8937 }
8938 }
8939 deserializer.deserialize_identifier(GeneratedVisitor)
8940 }
8941 }
8942 struct GeneratedVisitor;
8943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8944 type Value = ListCompactTaskProgressResponse;
8945
8946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8947 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
8948 }
8949
8950 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
8951 where
8952 V: serde::de::MapAccess<'de>,
8953 {
8954 let mut task_progress__ = None;
8955 while let Some(k) = map_.next_key()? {
8956 match k {
8957 GeneratedField::TaskProgress => {
8958 if task_progress__.is_some() {
8959 return Err(serde::de::Error::duplicate_field("taskProgress"));
8960 }
8961 task_progress__ = Some(map_.next_value()?);
8962 }
8963 }
8964 }
8965 Ok(ListCompactTaskProgressResponse {
8966 task_progress: task_progress__.unwrap_or_default(),
8967 })
8968 }
8969 }
8970 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
8971 }
8972}
8973impl serde::Serialize for ListHummockMetaConfigRequest {
8974 #[allow(deprecated)]
8975 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8976 where
8977 S: serde::Serializer,
8978 {
8979 use serde::ser::SerializeStruct;
8980 let len = 0;
8981 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
8982 struct_ser.end()
8983 }
8984}
8985impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
8986 #[allow(deprecated)]
8987 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8988 where
8989 D: serde::Deserializer<'de>,
8990 {
8991 const FIELDS: &[&str] = &[
8992 ];
8993
8994 #[allow(clippy::enum_variant_names)]
8995 enum GeneratedField {
8996 }
8997 impl<'de> serde::Deserialize<'de> for GeneratedField {
8998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8999 where
9000 D: serde::Deserializer<'de>,
9001 {
9002 struct GeneratedVisitor;
9003
9004 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9005 type Value = GeneratedField;
9006
9007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9008 write!(formatter, "expected one of: {:?}", &FIELDS)
9009 }
9010
9011 #[allow(unused_variables)]
9012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9013 where
9014 E: serde::de::Error,
9015 {
9016 Err(serde::de::Error::unknown_field(value, FIELDS))
9017 }
9018 }
9019 deserializer.deserialize_identifier(GeneratedVisitor)
9020 }
9021 }
9022 struct GeneratedVisitor;
9023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9024 type Value = ListHummockMetaConfigRequest;
9025
9026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9027 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
9028 }
9029
9030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
9031 where
9032 V: serde::de::MapAccess<'de>,
9033 {
9034 while map_.next_key::<GeneratedField>()?.is_some() {
9035 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9036 }
9037 Ok(ListHummockMetaConfigRequest {
9038 })
9039 }
9040 }
9041 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
9042 }
9043}
9044impl serde::Serialize for ListHummockMetaConfigResponse {
9045 #[allow(deprecated)]
9046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9047 where
9048 S: serde::Serializer,
9049 {
9050 use serde::ser::SerializeStruct;
9051 let mut len = 0;
9052 if !self.configs.is_empty() {
9053 len += 1;
9054 }
9055 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
9056 if !self.configs.is_empty() {
9057 struct_ser.serialize_field("configs", &self.configs)?;
9058 }
9059 struct_ser.end()
9060 }
9061}
9062impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
9063 #[allow(deprecated)]
9064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9065 where
9066 D: serde::Deserializer<'de>,
9067 {
9068 const FIELDS: &[&str] = &[
9069 "configs",
9070 ];
9071
9072 #[allow(clippy::enum_variant_names)]
9073 enum GeneratedField {
9074 Configs,
9075 }
9076 impl<'de> serde::Deserialize<'de> for GeneratedField {
9077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9078 where
9079 D: serde::Deserializer<'de>,
9080 {
9081 struct GeneratedVisitor;
9082
9083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9084 type Value = GeneratedField;
9085
9086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9087 write!(formatter, "expected one of: {:?}", &FIELDS)
9088 }
9089
9090 #[allow(unused_variables)]
9091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9092 where
9093 E: serde::de::Error,
9094 {
9095 match value {
9096 "configs" => Ok(GeneratedField::Configs),
9097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9098 }
9099 }
9100 }
9101 deserializer.deserialize_identifier(GeneratedVisitor)
9102 }
9103 }
9104 struct GeneratedVisitor;
9105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9106 type Value = ListHummockMetaConfigResponse;
9107
9108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9109 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
9110 }
9111
9112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
9113 where
9114 V: serde::de::MapAccess<'de>,
9115 {
9116 let mut configs__ = None;
9117 while let Some(k) = map_.next_key()? {
9118 match k {
9119 GeneratedField::Configs => {
9120 if configs__.is_some() {
9121 return Err(serde::de::Error::duplicate_field("configs"));
9122 }
9123 configs__ = Some(
9124 map_.next_value::<std::collections::HashMap<_, _>>()?
9125 );
9126 }
9127 }
9128 }
9129 Ok(ListHummockMetaConfigResponse {
9130 configs: configs__.unwrap_or_default(),
9131 })
9132 }
9133 }
9134 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
9135 }
9136}
9137impl serde::Serialize for ListVersionDeltasRequest {
9138 #[allow(deprecated)]
9139 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9140 where
9141 S: serde::Serializer,
9142 {
9143 use serde::ser::SerializeStruct;
9144 let mut len = 0;
9145 if self.start_id != 0 {
9146 len += 1;
9147 }
9148 if self.num_limit != 0 {
9149 len += 1;
9150 }
9151 if self.committed_epoch_limit != 0 {
9152 len += 1;
9153 }
9154 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
9155 if self.start_id != 0 {
9156 #[allow(clippy::needless_borrow)]
9157 #[allow(clippy::needless_borrows_for_generic_args)]
9158 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
9159 }
9160 if self.num_limit != 0 {
9161 struct_ser.serialize_field("numLimit", &self.num_limit)?;
9162 }
9163 if self.committed_epoch_limit != 0 {
9164 #[allow(clippy::needless_borrow)]
9165 #[allow(clippy::needless_borrows_for_generic_args)]
9166 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
9167 }
9168 struct_ser.end()
9169 }
9170}
9171impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
9172 #[allow(deprecated)]
9173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9174 where
9175 D: serde::Deserializer<'de>,
9176 {
9177 const FIELDS: &[&str] = &[
9178 "start_id",
9179 "startId",
9180 "num_limit",
9181 "numLimit",
9182 "committed_epoch_limit",
9183 "committedEpochLimit",
9184 ];
9185
9186 #[allow(clippy::enum_variant_names)]
9187 enum GeneratedField {
9188 StartId,
9189 NumLimit,
9190 CommittedEpochLimit,
9191 }
9192 impl<'de> serde::Deserialize<'de> for GeneratedField {
9193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9194 where
9195 D: serde::Deserializer<'de>,
9196 {
9197 struct GeneratedVisitor;
9198
9199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9200 type Value = GeneratedField;
9201
9202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9203 write!(formatter, "expected one of: {:?}", &FIELDS)
9204 }
9205
9206 #[allow(unused_variables)]
9207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9208 where
9209 E: serde::de::Error,
9210 {
9211 match value {
9212 "startId" | "start_id" => Ok(GeneratedField::StartId),
9213 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
9214 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
9215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9216 }
9217 }
9218 }
9219 deserializer.deserialize_identifier(GeneratedVisitor)
9220 }
9221 }
9222 struct GeneratedVisitor;
9223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9224 type Value = ListVersionDeltasRequest;
9225
9226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9227 formatter.write_str("struct hummock.ListVersionDeltasRequest")
9228 }
9229
9230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
9231 where
9232 V: serde::de::MapAccess<'de>,
9233 {
9234 let mut start_id__ = None;
9235 let mut num_limit__ = None;
9236 let mut committed_epoch_limit__ = None;
9237 while let Some(k) = map_.next_key()? {
9238 match k {
9239 GeneratedField::StartId => {
9240 if start_id__.is_some() {
9241 return Err(serde::de::Error::duplicate_field("startId"));
9242 }
9243 start_id__ =
9244 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9245 ;
9246 }
9247 GeneratedField::NumLimit => {
9248 if num_limit__.is_some() {
9249 return Err(serde::de::Error::duplicate_field("numLimit"));
9250 }
9251 num_limit__ =
9252 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9253 ;
9254 }
9255 GeneratedField::CommittedEpochLimit => {
9256 if committed_epoch_limit__.is_some() {
9257 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
9258 }
9259 committed_epoch_limit__ =
9260 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9261 ;
9262 }
9263 }
9264 }
9265 Ok(ListVersionDeltasRequest {
9266 start_id: start_id__.unwrap_or_default(),
9267 num_limit: num_limit__.unwrap_or_default(),
9268 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
9269 })
9270 }
9271 }
9272 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
9273 }
9274}
9275impl serde::Serialize for ListVersionDeltasResponse {
9276 #[allow(deprecated)]
9277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9278 where
9279 S: serde::Serializer,
9280 {
9281 use serde::ser::SerializeStruct;
9282 let mut len = 0;
9283 if self.version_deltas.is_some() {
9284 len += 1;
9285 }
9286 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
9287 if let Some(v) = self.version_deltas.as_ref() {
9288 struct_ser.serialize_field("versionDeltas", v)?;
9289 }
9290 struct_ser.end()
9291 }
9292}
9293impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
9294 #[allow(deprecated)]
9295 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9296 where
9297 D: serde::Deserializer<'de>,
9298 {
9299 const FIELDS: &[&str] = &[
9300 "version_deltas",
9301 "versionDeltas",
9302 ];
9303
9304 #[allow(clippy::enum_variant_names)]
9305 enum GeneratedField {
9306 VersionDeltas,
9307 }
9308 impl<'de> serde::Deserialize<'de> for GeneratedField {
9309 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9310 where
9311 D: serde::Deserializer<'de>,
9312 {
9313 struct GeneratedVisitor;
9314
9315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9316 type Value = GeneratedField;
9317
9318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9319 write!(formatter, "expected one of: {:?}", &FIELDS)
9320 }
9321
9322 #[allow(unused_variables)]
9323 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9324 where
9325 E: serde::de::Error,
9326 {
9327 match value {
9328 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
9329 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9330 }
9331 }
9332 }
9333 deserializer.deserialize_identifier(GeneratedVisitor)
9334 }
9335 }
9336 struct GeneratedVisitor;
9337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9338 type Value = ListVersionDeltasResponse;
9339
9340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9341 formatter.write_str("struct hummock.ListVersionDeltasResponse")
9342 }
9343
9344 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
9345 where
9346 V: serde::de::MapAccess<'de>,
9347 {
9348 let mut version_deltas__ = None;
9349 while let Some(k) = map_.next_key()? {
9350 match k {
9351 GeneratedField::VersionDeltas => {
9352 if version_deltas__.is_some() {
9353 return Err(serde::de::Error::duplicate_field("versionDeltas"));
9354 }
9355 version_deltas__ = map_.next_value()?;
9356 }
9357 }
9358 }
9359 Ok(ListVersionDeltasResponse {
9360 version_deltas: version_deltas__,
9361 })
9362 }
9363 }
9364 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
9365 }
9366}
9367impl serde::Serialize for MergeCompactionGroupRequest {
9368 #[allow(deprecated)]
9369 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9370 where
9371 S: serde::Serializer,
9372 {
9373 use serde::ser::SerializeStruct;
9374 let mut len = 0;
9375 if self.left_group_id != 0 {
9376 len += 1;
9377 }
9378 if self.right_group_id != 0 {
9379 len += 1;
9380 }
9381 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
9382 if self.left_group_id != 0 {
9383 #[allow(clippy::needless_borrow)]
9384 #[allow(clippy::needless_borrows_for_generic_args)]
9385 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
9386 }
9387 if self.right_group_id != 0 {
9388 #[allow(clippy::needless_borrow)]
9389 #[allow(clippy::needless_borrows_for_generic_args)]
9390 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
9391 }
9392 struct_ser.end()
9393 }
9394}
9395impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
9396 #[allow(deprecated)]
9397 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9398 where
9399 D: serde::Deserializer<'de>,
9400 {
9401 const FIELDS: &[&str] = &[
9402 "left_group_id",
9403 "leftGroupId",
9404 "right_group_id",
9405 "rightGroupId",
9406 ];
9407
9408 #[allow(clippy::enum_variant_names)]
9409 enum GeneratedField {
9410 LeftGroupId,
9411 RightGroupId,
9412 }
9413 impl<'de> serde::Deserialize<'de> for GeneratedField {
9414 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9415 where
9416 D: serde::Deserializer<'de>,
9417 {
9418 struct GeneratedVisitor;
9419
9420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9421 type Value = GeneratedField;
9422
9423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9424 write!(formatter, "expected one of: {:?}", &FIELDS)
9425 }
9426
9427 #[allow(unused_variables)]
9428 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9429 where
9430 E: serde::de::Error,
9431 {
9432 match value {
9433 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
9434 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
9435 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9436 }
9437 }
9438 }
9439 deserializer.deserialize_identifier(GeneratedVisitor)
9440 }
9441 }
9442 struct GeneratedVisitor;
9443 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9444 type Value = MergeCompactionGroupRequest;
9445
9446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9447 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
9448 }
9449
9450 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
9451 where
9452 V: serde::de::MapAccess<'de>,
9453 {
9454 let mut left_group_id__ = None;
9455 let mut right_group_id__ = None;
9456 while let Some(k) = map_.next_key()? {
9457 match k {
9458 GeneratedField::LeftGroupId => {
9459 if left_group_id__.is_some() {
9460 return Err(serde::de::Error::duplicate_field("leftGroupId"));
9461 }
9462 left_group_id__ =
9463 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9464 ;
9465 }
9466 GeneratedField::RightGroupId => {
9467 if right_group_id__.is_some() {
9468 return Err(serde::de::Error::duplicate_field("rightGroupId"));
9469 }
9470 right_group_id__ =
9471 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9472 ;
9473 }
9474 }
9475 }
9476 Ok(MergeCompactionGroupRequest {
9477 left_group_id: left_group_id__.unwrap_or_default(),
9478 right_group_id: right_group_id__.unwrap_or_default(),
9479 })
9480 }
9481 }
9482 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
9483 }
9484}
9485impl serde::Serialize for MergeCompactionGroupResponse {
9486 #[allow(deprecated)]
9487 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9488 where
9489 S: serde::Serializer,
9490 {
9491 use serde::ser::SerializeStruct;
9492 let len = 0;
9493 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
9494 struct_ser.end()
9495 }
9496}
9497impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
9498 #[allow(deprecated)]
9499 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9500 where
9501 D: serde::Deserializer<'de>,
9502 {
9503 const FIELDS: &[&str] = &[
9504 ];
9505
9506 #[allow(clippy::enum_variant_names)]
9507 enum GeneratedField {
9508 }
9509 impl<'de> serde::Deserialize<'de> for GeneratedField {
9510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9511 where
9512 D: serde::Deserializer<'de>,
9513 {
9514 struct GeneratedVisitor;
9515
9516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9517 type Value = GeneratedField;
9518
9519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9520 write!(formatter, "expected one of: {:?}", &FIELDS)
9521 }
9522
9523 #[allow(unused_variables)]
9524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9525 where
9526 E: serde::de::Error,
9527 {
9528 Err(serde::de::Error::unknown_field(value, FIELDS))
9529 }
9530 }
9531 deserializer.deserialize_identifier(GeneratedVisitor)
9532 }
9533 }
9534 struct GeneratedVisitor;
9535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9536 type Value = MergeCompactionGroupResponse;
9537
9538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9539 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
9540 }
9541
9542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
9543 where
9544 V: serde::de::MapAccess<'de>,
9545 {
9546 while map_.next_key::<GeneratedField>()?.is_some() {
9547 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9548 }
9549 Ok(MergeCompactionGroupResponse {
9550 })
9551 }
9552 }
9553 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
9554 }
9555}
9556impl serde::Serialize for NewL0SubLevel {
9557 #[allow(deprecated)]
9558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9559 where
9560 S: serde::Serializer,
9561 {
9562 use serde::ser::SerializeStruct;
9563 let mut len = 0;
9564 if !self.inserted_table_infos.is_empty() {
9565 len += 1;
9566 }
9567 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
9568 if !self.inserted_table_infos.is_empty() {
9569 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
9570 }
9571 struct_ser.end()
9572 }
9573}
9574impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
9575 #[allow(deprecated)]
9576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9577 where
9578 D: serde::Deserializer<'de>,
9579 {
9580 const FIELDS: &[&str] = &[
9581 "inserted_table_infos",
9582 "insertedTableInfos",
9583 ];
9584
9585 #[allow(clippy::enum_variant_names)]
9586 enum GeneratedField {
9587 InsertedTableInfos,
9588 }
9589 impl<'de> serde::Deserialize<'de> for GeneratedField {
9590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9591 where
9592 D: serde::Deserializer<'de>,
9593 {
9594 struct GeneratedVisitor;
9595
9596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9597 type Value = GeneratedField;
9598
9599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9600 write!(formatter, "expected one of: {:?}", &FIELDS)
9601 }
9602
9603 #[allow(unused_variables)]
9604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9605 where
9606 E: serde::de::Error,
9607 {
9608 match value {
9609 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
9610 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9611 }
9612 }
9613 }
9614 deserializer.deserialize_identifier(GeneratedVisitor)
9615 }
9616 }
9617 struct GeneratedVisitor;
9618 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9619 type Value = NewL0SubLevel;
9620
9621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9622 formatter.write_str("struct hummock.NewL0SubLevel")
9623 }
9624
9625 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
9626 where
9627 V: serde::de::MapAccess<'de>,
9628 {
9629 let mut inserted_table_infos__ = None;
9630 while let Some(k) = map_.next_key()? {
9631 match k {
9632 GeneratedField::InsertedTableInfos => {
9633 if inserted_table_infos__.is_some() {
9634 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
9635 }
9636 inserted_table_infos__ = Some(map_.next_value()?);
9637 }
9638 }
9639 }
9640 Ok(NewL0SubLevel {
9641 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
9642 })
9643 }
9644 }
9645 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
9646 }
9647}
9648impl serde::Serialize for OverlappingLevel {
9649 #[allow(deprecated)]
9650 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9651 where
9652 S: serde::Serializer,
9653 {
9654 use serde::ser::SerializeStruct;
9655 let mut len = 0;
9656 if !self.sub_levels.is_empty() {
9657 len += 1;
9658 }
9659 if self.total_file_size != 0 {
9660 len += 1;
9661 }
9662 if self.uncompressed_file_size != 0 {
9663 len += 1;
9664 }
9665 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
9666 if !self.sub_levels.is_empty() {
9667 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
9668 }
9669 if self.total_file_size != 0 {
9670 #[allow(clippy::needless_borrow)]
9671 #[allow(clippy::needless_borrows_for_generic_args)]
9672 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9673 }
9674 if self.uncompressed_file_size != 0 {
9675 #[allow(clippy::needless_borrow)]
9676 #[allow(clippy::needless_borrows_for_generic_args)]
9677 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
9678 }
9679 struct_ser.end()
9680 }
9681}
9682impl<'de> serde::Deserialize<'de> for OverlappingLevel {
9683 #[allow(deprecated)]
9684 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9685 where
9686 D: serde::Deserializer<'de>,
9687 {
9688 const FIELDS: &[&str] = &[
9689 "sub_levels",
9690 "subLevels",
9691 "total_file_size",
9692 "totalFileSize",
9693 "uncompressed_file_size",
9694 "uncompressedFileSize",
9695 ];
9696
9697 #[allow(clippy::enum_variant_names)]
9698 enum GeneratedField {
9699 SubLevels,
9700 TotalFileSize,
9701 UncompressedFileSize,
9702 }
9703 impl<'de> serde::Deserialize<'de> for GeneratedField {
9704 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9705 where
9706 D: serde::Deserializer<'de>,
9707 {
9708 struct GeneratedVisitor;
9709
9710 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9711 type Value = GeneratedField;
9712
9713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9714 write!(formatter, "expected one of: {:?}", &FIELDS)
9715 }
9716
9717 #[allow(unused_variables)]
9718 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9719 where
9720 E: serde::de::Error,
9721 {
9722 match value {
9723 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
9724 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9725 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
9726 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9727 }
9728 }
9729 }
9730 deserializer.deserialize_identifier(GeneratedVisitor)
9731 }
9732 }
9733 struct GeneratedVisitor;
9734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9735 type Value = OverlappingLevel;
9736
9737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9738 formatter.write_str("struct hummock.OverlappingLevel")
9739 }
9740
9741 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
9742 where
9743 V: serde::de::MapAccess<'de>,
9744 {
9745 let mut sub_levels__ = None;
9746 let mut total_file_size__ = None;
9747 let mut uncompressed_file_size__ = None;
9748 while let Some(k) = map_.next_key()? {
9749 match k {
9750 GeneratedField::SubLevels => {
9751 if sub_levels__.is_some() {
9752 return Err(serde::de::Error::duplicate_field("subLevels"));
9753 }
9754 sub_levels__ = Some(map_.next_value()?);
9755 }
9756 GeneratedField::TotalFileSize => {
9757 if total_file_size__.is_some() {
9758 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9759 }
9760 total_file_size__ =
9761 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9762 ;
9763 }
9764 GeneratedField::UncompressedFileSize => {
9765 if uncompressed_file_size__.is_some() {
9766 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
9767 }
9768 uncompressed_file_size__ =
9769 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9770 ;
9771 }
9772 }
9773 }
9774 Ok(OverlappingLevel {
9775 sub_levels: sub_levels__.unwrap_or_default(),
9776 total_file_size: total_file_size__.unwrap_or_default(),
9777 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
9778 })
9779 }
9780 }
9781 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
9782 }
9783}
9784impl serde::Serialize for PinVersionRequest {
9785 #[allow(deprecated)]
9786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9787 where
9788 S: serde::Serializer,
9789 {
9790 use serde::ser::SerializeStruct;
9791 let mut len = 0;
9792 if self.context_id != 0 {
9793 len += 1;
9794 }
9795 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
9796 if self.context_id != 0 {
9797 struct_ser.serialize_field("contextId", &self.context_id)?;
9798 }
9799 struct_ser.end()
9800 }
9801}
9802impl<'de> serde::Deserialize<'de> for PinVersionRequest {
9803 #[allow(deprecated)]
9804 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9805 where
9806 D: serde::Deserializer<'de>,
9807 {
9808 const FIELDS: &[&str] = &[
9809 "context_id",
9810 "contextId",
9811 ];
9812
9813 #[allow(clippy::enum_variant_names)]
9814 enum GeneratedField {
9815 ContextId,
9816 }
9817 impl<'de> serde::Deserialize<'de> for GeneratedField {
9818 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9819 where
9820 D: serde::Deserializer<'de>,
9821 {
9822 struct GeneratedVisitor;
9823
9824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9825 type Value = GeneratedField;
9826
9827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9828 write!(formatter, "expected one of: {:?}", &FIELDS)
9829 }
9830
9831 #[allow(unused_variables)]
9832 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9833 where
9834 E: serde::de::Error,
9835 {
9836 match value {
9837 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
9838 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9839 }
9840 }
9841 }
9842 deserializer.deserialize_identifier(GeneratedVisitor)
9843 }
9844 }
9845 struct GeneratedVisitor;
9846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9847 type Value = PinVersionRequest;
9848
9849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9850 formatter.write_str("struct hummock.PinVersionRequest")
9851 }
9852
9853 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
9854 where
9855 V: serde::de::MapAccess<'de>,
9856 {
9857 let mut context_id__ = None;
9858 while let Some(k) = map_.next_key()? {
9859 match k {
9860 GeneratedField::ContextId => {
9861 if context_id__.is_some() {
9862 return Err(serde::de::Error::duplicate_field("contextId"));
9863 }
9864 context_id__ =
9865 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9866 ;
9867 }
9868 }
9869 }
9870 Ok(PinVersionRequest {
9871 context_id: context_id__.unwrap_or_default(),
9872 })
9873 }
9874 }
9875 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
9876 }
9877}
9878impl serde::Serialize for PinVersionResponse {
9879 #[allow(deprecated)]
9880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9881 where
9882 S: serde::Serializer,
9883 {
9884 use serde::ser::SerializeStruct;
9885 let mut len = 0;
9886 if self.pinned_version.is_some() {
9887 len += 1;
9888 }
9889 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
9890 if let Some(v) = self.pinned_version.as_ref() {
9891 struct_ser.serialize_field("pinnedVersion", v)?;
9892 }
9893 struct_ser.end()
9894 }
9895}
9896impl<'de> serde::Deserialize<'de> for PinVersionResponse {
9897 #[allow(deprecated)]
9898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9899 where
9900 D: serde::Deserializer<'de>,
9901 {
9902 const FIELDS: &[&str] = &[
9903 "pinned_version",
9904 "pinnedVersion",
9905 ];
9906
9907 #[allow(clippy::enum_variant_names)]
9908 enum GeneratedField {
9909 PinnedVersion,
9910 }
9911 impl<'de> serde::Deserialize<'de> for GeneratedField {
9912 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9913 where
9914 D: serde::Deserializer<'de>,
9915 {
9916 struct GeneratedVisitor;
9917
9918 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9919 type Value = GeneratedField;
9920
9921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9922 write!(formatter, "expected one of: {:?}", &FIELDS)
9923 }
9924
9925 #[allow(unused_variables)]
9926 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9927 where
9928 E: serde::de::Error,
9929 {
9930 match value {
9931 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
9932 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9933 }
9934 }
9935 }
9936 deserializer.deserialize_identifier(GeneratedVisitor)
9937 }
9938 }
9939 struct GeneratedVisitor;
9940 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9941 type Value = PinVersionResponse;
9942
9943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9944 formatter.write_str("struct hummock.PinVersionResponse")
9945 }
9946
9947 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
9948 where
9949 V: serde::de::MapAccess<'de>,
9950 {
9951 let mut pinned_version__ = None;
9952 while let Some(k) = map_.next_key()? {
9953 match k {
9954 GeneratedField::PinnedVersion => {
9955 if pinned_version__.is_some() {
9956 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
9957 }
9958 pinned_version__ = map_.next_value()?;
9959 }
9960 }
9961 }
9962 Ok(PinVersionResponse {
9963 pinned_version: pinned_version__,
9964 })
9965 }
9966 }
9967 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
9968 }
9969}
9970impl serde::Serialize for PinnedVersionsSummary {
9971 #[allow(deprecated)]
9972 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9973 where
9974 S: serde::Serializer,
9975 {
9976 use serde::ser::SerializeStruct;
9977 let mut len = 0;
9978 if !self.pinned_versions.is_empty() {
9979 len += 1;
9980 }
9981 if !self.workers.is_empty() {
9982 len += 1;
9983 }
9984 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
9985 if !self.pinned_versions.is_empty() {
9986 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
9987 }
9988 if !self.workers.is_empty() {
9989 struct_ser.serialize_field("workers", &self.workers)?;
9990 }
9991 struct_ser.end()
9992 }
9993}
9994impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
9995 #[allow(deprecated)]
9996 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9997 where
9998 D: serde::Deserializer<'de>,
9999 {
10000 const FIELDS: &[&str] = &[
10001 "pinned_versions",
10002 "pinnedVersions",
10003 "workers",
10004 ];
10005
10006 #[allow(clippy::enum_variant_names)]
10007 enum GeneratedField {
10008 PinnedVersions,
10009 Workers,
10010 }
10011 impl<'de> serde::Deserialize<'de> for GeneratedField {
10012 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10013 where
10014 D: serde::Deserializer<'de>,
10015 {
10016 struct GeneratedVisitor;
10017
10018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10019 type Value = GeneratedField;
10020
10021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10022 write!(formatter, "expected one of: {:?}", &FIELDS)
10023 }
10024
10025 #[allow(unused_variables)]
10026 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10027 where
10028 E: serde::de::Error,
10029 {
10030 match value {
10031 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
10032 "workers" => Ok(GeneratedField::Workers),
10033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10034 }
10035 }
10036 }
10037 deserializer.deserialize_identifier(GeneratedVisitor)
10038 }
10039 }
10040 struct GeneratedVisitor;
10041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10042 type Value = PinnedVersionsSummary;
10043
10044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10045 formatter.write_str("struct hummock.PinnedVersionsSummary")
10046 }
10047
10048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
10049 where
10050 V: serde::de::MapAccess<'de>,
10051 {
10052 let mut pinned_versions__ = None;
10053 let mut workers__ = None;
10054 while let Some(k) = map_.next_key()? {
10055 match k {
10056 GeneratedField::PinnedVersions => {
10057 if pinned_versions__.is_some() {
10058 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
10059 }
10060 pinned_versions__ = Some(map_.next_value()?);
10061 }
10062 GeneratedField::Workers => {
10063 if workers__.is_some() {
10064 return Err(serde::de::Error::duplicate_field("workers"));
10065 }
10066 workers__ = Some(
10067 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10068 .into_iter().map(|(k,v)| (k.0, v)).collect()
10069 );
10070 }
10071 }
10072 }
10073 Ok(PinnedVersionsSummary {
10074 pinned_versions: pinned_versions__.unwrap_or_default(),
10075 workers: workers__.unwrap_or_default(),
10076 })
10077 }
10078 }
10079 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
10080 }
10081}
10082impl serde::Serialize for ReplayVersionDeltaRequest {
10083 #[allow(deprecated)]
10084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10085 where
10086 S: serde::Serializer,
10087 {
10088 use serde::ser::SerializeStruct;
10089 let mut len = 0;
10090 if self.version_delta.is_some() {
10091 len += 1;
10092 }
10093 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
10094 if let Some(v) = self.version_delta.as_ref() {
10095 struct_ser.serialize_field("versionDelta", v)?;
10096 }
10097 struct_ser.end()
10098 }
10099}
10100impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
10101 #[allow(deprecated)]
10102 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10103 where
10104 D: serde::Deserializer<'de>,
10105 {
10106 const FIELDS: &[&str] = &[
10107 "version_delta",
10108 "versionDelta",
10109 ];
10110
10111 #[allow(clippy::enum_variant_names)]
10112 enum GeneratedField {
10113 VersionDelta,
10114 }
10115 impl<'de> serde::Deserialize<'de> for GeneratedField {
10116 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10117 where
10118 D: serde::Deserializer<'de>,
10119 {
10120 struct GeneratedVisitor;
10121
10122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10123 type Value = GeneratedField;
10124
10125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10126 write!(formatter, "expected one of: {:?}", &FIELDS)
10127 }
10128
10129 #[allow(unused_variables)]
10130 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10131 where
10132 E: serde::de::Error,
10133 {
10134 match value {
10135 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
10136 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10137 }
10138 }
10139 }
10140 deserializer.deserialize_identifier(GeneratedVisitor)
10141 }
10142 }
10143 struct GeneratedVisitor;
10144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10145 type Value = ReplayVersionDeltaRequest;
10146
10147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10148 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
10149 }
10150
10151 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
10152 where
10153 V: serde::de::MapAccess<'de>,
10154 {
10155 let mut version_delta__ = None;
10156 while let Some(k) = map_.next_key()? {
10157 match k {
10158 GeneratedField::VersionDelta => {
10159 if version_delta__.is_some() {
10160 return Err(serde::de::Error::duplicate_field("versionDelta"));
10161 }
10162 version_delta__ = map_.next_value()?;
10163 }
10164 }
10165 }
10166 Ok(ReplayVersionDeltaRequest {
10167 version_delta: version_delta__,
10168 })
10169 }
10170 }
10171 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
10172 }
10173}
10174impl serde::Serialize for ReplayVersionDeltaResponse {
10175 #[allow(deprecated)]
10176 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10177 where
10178 S: serde::Serializer,
10179 {
10180 use serde::ser::SerializeStruct;
10181 let mut len = 0;
10182 if self.version.is_some() {
10183 len += 1;
10184 }
10185 if !self.modified_compaction_groups.is_empty() {
10186 len += 1;
10187 }
10188 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
10189 if let Some(v) = self.version.as_ref() {
10190 struct_ser.serialize_field("version", v)?;
10191 }
10192 if !self.modified_compaction_groups.is_empty() {
10193 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
10194 }
10195 struct_ser.end()
10196 }
10197}
10198impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
10199 #[allow(deprecated)]
10200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10201 where
10202 D: serde::Deserializer<'de>,
10203 {
10204 const FIELDS: &[&str] = &[
10205 "version",
10206 "modified_compaction_groups",
10207 "modifiedCompactionGroups",
10208 ];
10209
10210 #[allow(clippy::enum_variant_names)]
10211 enum GeneratedField {
10212 Version,
10213 ModifiedCompactionGroups,
10214 }
10215 impl<'de> serde::Deserialize<'de> for GeneratedField {
10216 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10217 where
10218 D: serde::Deserializer<'de>,
10219 {
10220 struct GeneratedVisitor;
10221
10222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10223 type Value = GeneratedField;
10224
10225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10226 write!(formatter, "expected one of: {:?}", &FIELDS)
10227 }
10228
10229 #[allow(unused_variables)]
10230 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10231 where
10232 E: serde::de::Error,
10233 {
10234 match value {
10235 "version" => Ok(GeneratedField::Version),
10236 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
10237 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10238 }
10239 }
10240 }
10241 deserializer.deserialize_identifier(GeneratedVisitor)
10242 }
10243 }
10244 struct GeneratedVisitor;
10245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10246 type Value = ReplayVersionDeltaResponse;
10247
10248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10249 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
10250 }
10251
10252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
10253 where
10254 V: serde::de::MapAccess<'de>,
10255 {
10256 let mut version__ = None;
10257 let mut modified_compaction_groups__ = None;
10258 while let Some(k) = map_.next_key()? {
10259 match k {
10260 GeneratedField::Version => {
10261 if version__.is_some() {
10262 return Err(serde::de::Error::duplicate_field("version"));
10263 }
10264 version__ = map_.next_value()?;
10265 }
10266 GeneratedField::ModifiedCompactionGroups => {
10267 if modified_compaction_groups__.is_some() {
10268 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
10269 }
10270 modified_compaction_groups__ =
10271 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10272 .into_iter().map(|x| x.0).collect())
10273 ;
10274 }
10275 }
10276 }
10277 Ok(ReplayVersionDeltaResponse {
10278 version: version__,
10279 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
10280 })
10281 }
10282 }
10283 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
10284 }
10285}
10286impl serde::Serialize for ReportCompactionTaskRequest {
10287 #[allow(deprecated)]
10288 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10289 where
10290 S: serde::Serializer,
10291 {
10292 use serde::ser::SerializeStruct;
10293 let mut len = 0;
10294 if self.event.is_some() {
10295 len += 1;
10296 }
10297 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
10298 if let Some(v) = self.event.as_ref() {
10299 match v {
10300 report_compaction_task_request::Event::ReportTask(v) => {
10301 struct_ser.serialize_field("reportTask", v)?;
10302 }
10303 report_compaction_task_request::Event::HeartBeat(v) => {
10304 struct_ser.serialize_field("heartBeat", v)?;
10305 }
10306 }
10307 }
10308 struct_ser.end()
10309 }
10310}
10311impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
10312 #[allow(deprecated)]
10313 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10314 where
10315 D: serde::Deserializer<'de>,
10316 {
10317 const FIELDS: &[&str] = &[
10318 "report_task",
10319 "reportTask",
10320 "heart_beat",
10321 "heartBeat",
10322 ];
10323
10324 #[allow(clippy::enum_variant_names)]
10325 enum GeneratedField {
10326 ReportTask,
10327 HeartBeat,
10328 }
10329 impl<'de> serde::Deserialize<'de> for GeneratedField {
10330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10331 where
10332 D: serde::Deserializer<'de>,
10333 {
10334 struct GeneratedVisitor;
10335
10336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10337 type Value = GeneratedField;
10338
10339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10340 write!(formatter, "expected one of: {:?}", &FIELDS)
10341 }
10342
10343 #[allow(unused_variables)]
10344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10345 where
10346 E: serde::de::Error,
10347 {
10348 match value {
10349 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
10350 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
10351 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10352 }
10353 }
10354 }
10355 deserializer.deserialize_identifier(GeneratedVisitor)
10356 }
10357 }
10358 struct GeneratedVisitor;
10359 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10360 type Value = ReportCompactionTaskRequest;
10361
10362 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10363 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
10364 }
10365
10366 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
10367 where
10368 V: serde::de::MapAccess<'de>,
10369 {
10370 let mut event__ = None;
10371 while let Some(k) = map_.next_key()? {
10372 match k {
10373 GeneratedField::ReportTask => {
10374 if event__.is_some() {
10375 return Err(serde::de::Error::duplicate_field("reportTask"));
10376 }
10377 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
10378;
10379 }
10380 GeneratedField::HeartBeat => {
10381 if event__.is_some() {
10382 return Err(serde::de::Error::duplicate_field("heartBeat"));
10383 }
10384 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
10385;
10386 }
10387 }
10388 }
10389 Ok(ReportCompactionTaskRequest {
10390 event: event__,
10391 })
10392 }
10393 }
10394 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
10395 }
10396}
10397impl serde::Serialize for report_compaction_task_request::HeartBeat {
10398 #[allow(deprecated)]
10399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10400 where
10401 S: serde::Serializer,
10402 {
10403 use serde::ser::SerializeStruct;
10404 let mut len = 0;
10405 if !self.progress.is_empty() {
10406 len += 1;
10407 }
10408 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
10409 if !self.progress.is_empty() {
10410 struct_ser.serialize_field("progress", &self.progress)?;
10411 }
10412 struct_ser.end()
10413 }
10414}
10415impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
10416 #[allow(deprecated)]
10417 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10418 where
10419 D: serde::Deserializer<'de>,
10420 {
10421 const FIELDS: &[&str] = &[
10422 "progress",
10423 ];
10424
10425 #[allow(clippy::enum_variant_names)]
10426 enum GeneratedField {
10427 Progress,
10428 }
10429 impl<'de> serde::Deserialize<'de> for GeneratedField {
10430 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10431 where
10432 D: serde::Deserializer<'de>,
10433 {
10434 struct GeneratedVisitor;
10435
10436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10437 type Value = GeneratedField;
10438
10439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10440 write!(formatter, "expected one of: {:?}", &FIELDS)
10441 }
10442
10443 #[allow(unused_variables)]
10444 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10445 where
10446 E: serde::de::Error,
10447 {
10448 match value {
10449 "progress" => Ok(GeneratedField::Progress),
10450 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10451 }
10452 }
10453 }
10454 deserializer.deserialize_identifier(GeneratedVisitor)
10455 }
10456 }
10457 struct GeneratedVisitor;
10458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10459 type Value = report_compaction_task_request::HeartBeat;
10460
10461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10462 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
10463 }
10464
10465 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
10466 where
10467 V: serde::de::MapAccess<'de>,
10468 {
10469 let mut progress__ = None;
10470 while let Some(k) = map_.next_key()? {
10471 match k {
10472 GeneratedField::Progress => {
10473 if progress__.is_some() {
10474 return Err(serde::de::Error::duplicate_field("progress"));
10475 }
10476 progress__ = Some(map_.next_value()?);
10477 }
10478 }
10479 }
10480 Ok(report_compaction_task_request::HeartBeat {
10481 progress: progress__.unwrap_or_default(),
10482 })
10483 }
10484 }
10485 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
10486 }
10487}
10488impl serde::Serialize for report_compaction_task_request::ReportTask {
10489 #[allow(deprecated)]
10490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10491 where
10492 S: serde::Serializer,
10493 {
10494 use serde::ser::SerializeStruct;
10495 let mut len = 0;
10496 if self.compact_task.is_some() {
10497 len += 1;
10498 }
10499 if !self.table_stats_change.is_empty() {
10500 len += 1;
10501 }
10502 if !self.object_timestamps.is_empty() {
10503 len += 1;
10504 }
10505 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
10506 if let Some(v) = self.compact_task.as_ref() {
10507 struct_ser.serialize_field("compactTask", v)?;
10508 }
10509 if !self.table_stats_change.is_empty() {
10510 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
10511 }
10512 if !self.object_timestamps.is_empty() {
10513 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
10514 .map(|(k, v)| (k, v.to_string())).collect();
10515 struct_ser.serialize_field("objectTimestamps", &v)?;
10516 }
10517 struct_ser.end()
10518 }
10519}
10520impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
10521 #[allow(deprecated)]
10522 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10523 where
10524 D: serde::Deserializer<'de>,
10525 {
10526 const FIELDS: &[&str] = &[
10527 "compact_task",
10528 "compactTask",
10529 "table_stats_change",
10530 "tableStatsChange",
10531 "object_timestamps",
10532 "objectTimestamps",
10533 ];
10534
10535 #[allow(clippy::enum_variant_names)]
10536 enum GeneratedField {
10537 CompactTask,
10538 TableStatsChange,
10539 ObjectTimestamps,
10540 }
10541 impl<'de> serde::Deserialize<'de> for GeneratedField {
10542 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10543 where
10544 D: serde::Deserializer<'de>,
10545 {
10546 struct GeneratedVisitor;
10547
10548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10549 type Value = GeneratedField;
10550
10551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10552 write!(formatter, "expected one of: {:?}", &FIELDS)
10553 }
10554
10555 #[allow(unused_variables)]
10556 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10557 where
10558 E: serde::de::Error,
10559 {
10560 match value {
10561 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
10562 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
10563 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
10564 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10565 }
10566 }
10567 }
10568 deserializer.deserialize_identifier(GeneratedVisitor)
10569 }
10570 }
10571 struct GeneratedVisitor;
10572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10573 type Value = report_compaction_task_request::ReportTask;
10574
10575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10576 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
10577 }
10578
10579 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
10580 where
10581 V: serde::de::MapAccess<'de>,
10582 {
10583 let mut compact_task__ = None;
10584 let mut table_stats_change__ = None;
10585 let mut object_timestamps__ = None;
10586 while let Some(k) = map_.next_key()? {
10587 match k {
10588 GeneratedField::CompactTask => {
10589 if compact_task__.is_some() {
10590 return Err(serde::de::Error::duplicate_field("compactTask"));
10591 }
10592 compact_task__ = map_.next_value()?;
10593 }
10594 GeneratedField::TableStatsChange => {
10595 if table_stats_change__.is_some() {
10596 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
10597 }
10598 table_stats_change__ = Some(
10599 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10600 .into_iter().map(|(k,v)| (k.0, v)).collect()
10601 );
10602 }
10603 GeneratedField::ObjectTimestamps => {
10604 if object_timestamps__.is_some() {
10605 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
10606 }
10607 object_timestamps__ = Some(
10608 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
10609 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
10610 );
10611 }
10612 }
10613 }
10614 Ok(report_compaction_task_request::ReportTask {
10615 compact_task: compact_task__,
10616 table_stats_change: table_stats_change__.unwrap_or_default(),
10617 object_timestamps: object_timestamps__.unwrap_or_default(),
10618 })
10619 }
10620 }
10621 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
10622 }
10623}
10624impl serde::Serialize for ReportCompactionTaskResponse {
10625 #[allow(deprecated)]
10626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10627 where
10628 S: serde::Serializer,
10629 {
10630 use serde::ser::SerializeStruct;
10631 let mut len = 0;
10632 if self.status.is_some() {
10633 len += 1;
10634 }
10635 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
10636 if let Some(v) = self.status.as_ref() {
10637 struct_ser.serialize_field("status", v)?;
10638 }
10639 struct_ser.end()
10640 }
10641}
10642impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
10643 #[allow(deprecated)]
10644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10645 where
10646 D: serde::Deserializer<'de>,
10647 {
10648 const FIELDS: &[&str] = &[
10649 "status",
10650 ];
10651
10652 #[allow(clippy::enum_variant_names)]
10653 enum GeneratedField {
10654 Status,
10655 }
10656 impl<'de> serde::Deserialize<'de> for GeneratedField {
10657 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10658 where
10659 D: serde::Deserializer<'de>,
10660 {
10661 struct GeneratedVisitor;
10662
10663 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10664 type Value = GeneratedField;
10665
10666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10667 write!(formatter, "expected one of: {:?}", &FIELDS)
10668 }
10669
10670 #[allow(unused_variables)]
10671 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10672 where
10673 E: serde::de::Error,
10674 {
10675 match value {
10676 "status" => Ok(GeneratedField::Status),
10677 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10678 }
10679 }
10680 }
10681 deserializer.deserialize_identifier(GeneratedVisitor)
10682 }
10683 }
10684 struct GeneratedVisitor;
10685 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10686 type Value = ReportCompactionTaskResponse;
10687
10688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10689 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
10690 }
10691
10692 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
10693 where
10694 V: serde::de::MapAccess<'de>,
10695 {
10696 let mut status__ = None;
10697 while let Some(k) = map_.next_key()? {
10698 match k {
10699 GeneratedField::Status => {
10700 if status__.is_some() {
10701 return Err(serde::de::Error::duplicate_field("status"));
10702 }
10703 status__ = map_.next_value()?;
10704 }
10705 }
10706 }
10707 Ok(ReportCompactionTaskResponse {
10708 status: status__,
10709 })
10710 }
10711 }
10712 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
10713 }
10714}
10715impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
10716 #[allow(deprecated)]
10717 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10718 where
10719 S: serde::Serializer,
10720 {
10721 use serde::ser::SerializeStruct;
10722 let len = 0;
10723 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
10724 struct_ser.end()
10725 }
10726}
10727impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
10728 #[allow(deprecated)]
10729 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10730 where
10731 D: serde::Deserializer<'de>,
10732 {
10733 const FIELDS: &[&str] = &[
10734 ];
10735
10736 #[allow(clippy::enum_variant_names)]
10737 enum GeneratedField {
10738 }
10739 impl<'de> serde::Deserialize<'de> for GeneratedField {
10740 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10741 where
10742 D: serde::Deserializer<'de>,
10743 {
10744 struct GeneratedVisitor;
10745
10746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10747 type Value = GeneratedField;
10748
10749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10750 write!(formatter, "expected one of: {:?}", &FIELDS)
10751 }
10752
10753 #[allow(unused_variables)]
10754 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10755 where
10756 E: serde::de::Error,
10757 {
10758 Err(serde::de::Error::unknown_field(value, FIELDS))
10759 }
10760 }
10761 deserializer.deserialize_identifier(GeneratedVisitor)
10762 }
10763 }
10764 struct GeneratedVisitor;
10765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10766 type Value = RiseCtlGetCheckpointVersionRequest;
10767
10768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10769 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
10770 }
10771
10772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
10773 where
10774 V: serde::de::MapAccess<'de>,
10775 {
10776 while map_.next_key::<GeneratedField>()?.is_some() {
10777 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10778 }
10779 Ok(RiseCtlGetCheckpointVersionRequest {
10780 })
10781 }
10782 }
10783 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
10784 }
10785}
10786impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
10787 #[allow(deprecated)]
10788 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10789 where
10790 S: serde::Serializer,
10791 {
10792 use serde::ser::SerializeStruct;
10793 let mut len = 0;
10794 if self.checkpoint_version.is_some() {
10795 len += 1;
10796 }
10797 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
10798 if let Some(v) = self.checkpoint_version.as_ref() {
10799 struct_ser.serialize_field("checkpointVersion", v)?;
10800 }
10801 struct_ser.end()
10802 }
10803}
10804impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
10805 #[allow(deprecated)]
10806 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10807 where
10808 D: serde::Deserializer<'de>,
10809 {
10810 const FIELDS: &[&str] = &[
10811 "checkpoint_version",
10812 "checkpointVersion",
10813 ];
10814
10815 #[allow(clippy::enum_variant_names)]
10816 enum GeneratedField {
10817 CheckpointVersion,
10818 }
10819 impl<'de> serde::Deserialize<'de> for GeneratedField {
10820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10821 where
10822 D: serde::Deserializer<'de>,
10823 {
10824 struct GeneratedVisitor;
10825
10826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10827 type Value = GeneratedField;
10828
10829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10830 write!(formatter, "expected one of: {:?}", &FIELDS)
10831 }
10832
10833 #[allow(unused_variables)]
10834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10835 where
10836 E: serde::de::Error,
10837 {
10838 match value {
10839 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
10840 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10841 }
10842 }
10843 }
10844 deserializer.deserialize_identifier(GeneratedVisitor)
10845 }
10846 }
10847 struct GeneratedVisitor;
10848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10849 type Value = RiseCtlGetCheckpointVersionResponse;
10850
10851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10852 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
10853 }
10854
10855 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
10856 where
10857 V: serde::de::MapAccess<'de>,
10858 {
10859 let mut checkpoint_version__ = None;
10860 while let Some(k) = map_.next_key()? {
10861 match k {
10862 GeneratedField::CheckpointVersion => {
10863 if checkpoint_version__.is_some() {
10864 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
10865 }
10866 checkpoint_version__ = map_.next_value()?;
10867 }
10868 }
10869 }
10870 Ok(RiseCtlGetCheckpointVersionResponse {
10871 checkpoint_version: checkpoint_version__,
10872 })
10873 }
10874 }
10875 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
10876 }
10877}
10878impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
10879 #[allow(deprecated)]
10880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10881 where
10882 S: serde::Serializer,
10883 {
10884 use serde::ser::SerializeStruct;
10885 let len = 0;
10886 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
10887 struct_ser.end()
10888 }
10889}
10890impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
10891 #[allow(deprecated)]
10892 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10893 where
10894 D: serde::Deserializer<'de>,
10895 {
10896 const FIELDS: &[&str] = &[
10897 ];
10898
10899 #[allow(clippy::enum_variant_names)]
10900 enum GeneratedField {
10901 }
10902 impl<'de> serde::Deserialize<'de> for GeneratedField {
10903 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10904 where
10905 D: serde::Deserializer<'de>,
10906 {
10907 struct GeneratedVisitor;
10908
10909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10910 type Value = GeneratedField;
10911
10912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10913 write!(formatter, "expected one of: {:?}", &FIELDS)
10914 }
10915
10916 #[allow(unused_variables)]
10917 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10918 where
10919 E: serde::de::Error,
10920 {
10921 Err(serde::de::Error::unknown_field(value, FIELDS))
10922 }
10923 }
10924 deserializer.deserialize_identifier(GeneratedVisitor)
10925 }
10926 }
10927 struct GeneratedVisitor;
10928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10929 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
10930
10931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10932 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
10933 }
10934
10935 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
10936 where
10937 V: serde::de::MapAccess<'de>,
10938 {
10939 while map_.next_key::<GeneratedField>()?.is_some() {
10940 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10941 }
10942 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
10943 })
10944 }
10945 }
10946 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
10947 }
10948}
10949impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
10950 #[allow(deprecated)]
10951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10952 where
10953 S: serde::Serializer,
10954 {
10955 use serde::ser::SerializeStruct;
10956 let mut len = 0;
10957 if self.summary.is_some() {
10958 len += 1;
10959 }
10960 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
10961 if let Some(v) = self.summary.as_ref() {
10962 struct_ser.serialize_field("summary", v)?;
10963 }
10964 struct_ser.end()
10965 }
10966}
10967impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
10968 #[allow(deprecated)]
10969 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10970 where
10971 D: serde::Deserializer<'de>,
10972 {
10973 const FIELDS: &[&str] = &[
10974 "summary",
10975 ];
10976
10977 #[allow(clippy::enum_variant_names)]
10978 enum GeneratedField {
10979 Summary,
10980 }
10981 impl<'de> serde::Deserialize<'de> for GeneratedField {
10982 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10983 where
10984 D: serde::Deserializer<'de>,
10985 {
10986 struct GeneratedVisitor;
10987
10988 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10989 type Value = GeneratedField;
10990
10991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10992 write!(formatter, "expected one of: {:?}", &FIELDS)
10993 }
10994
10995 #[allow(unused_variables)]
10996 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10997 where
10998 E: serde::de::Error,
10999 {
11000 match value {
11001 "summary" => Ok(GeneratedField::Summary),
11002 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11003 }
11004 }
11005 }
11006 deserializer.deserialize_identifier(GeneratedVisitor)
11007 }
11008 }
11009 struct GeneratedVisitor;
11010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11011 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
11012
11013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11014 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
11015 }
11016
11017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
11018 where
11019 V: serde::de::MapAccess<'de>,
11020 {
11021 let mut summary__ = None;
11022 while let Some(k) = map_.next_key()? {
11023 match k {
11024 GeneratedField::Summary => {
11025 if summary__.is_some() {
11026 return Err(serde::de::Error::duplicate_field("summary"));
11027 }
11028 summary__ = map_.next_value()?;
11029 }
11030 }
11031 }
11032 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
11033 summary: summary__,
11034 })
11035 }
11036 }
11037 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
11038 }
11039}
11040impl serde::Serialize for RiseCtlListCompactionGroupRequest {
11041 #[allow(deprecated)]
11042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11043 where
11044 S: serde::Serializer,
11045 {
11046 use serde::ser::SerializeStruct;
11047 let len = 0;
11048 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
11049 struct_ser.end()
11050 }
11051}
11052impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
11053 #[allow(deprecated)]
11054 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11055 where
11056 D: serde::Deserializer<'de>,
11057 {
11058 const FIELDS: &[&str] = &[
11059 ];
11060
11061 #[allow(clippy::enum_variant_names)]
11062 enum GeneratedField {
11063 }
11064 impl<'de> serde::Deserialize<'de> for GeneratedField {
11065 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11066 where
11067 D: serde::Deserializer<'de>,
11068 {
11069 struct GeneratedVisitor;
11070
11071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11072 type Value = GeneratedField;
11073
11074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11075 write!(formatter, "expected one of: {:?}", &FIELDS)
11076 }
11077
11078 #[allow(unused_variables)]
11079 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11080 where
11081 E: serde::de::Error,
11082 {
11083 Err(serde::de::Error::unknown_field(value, FIELDS))
11084 }
11085 }
11086 deserializer.deserialize_identifier(GeneratedVisitor)
11087 }
11088 }
11089 struct GeneratedVisitor;
11090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11091 type Value = RiseCtlListCompactionGroupRequest;
11092
11093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11094 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
11095 }
11096
11097 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
11098 where
11099 V: serde::de::MapAccess<'de>,
11100 {
11101 while map_.next_key::<GeneratedField>()?.is_some() {
11102 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11103 }
11104 Ok(RiseCtlListCompactionGroupRequest {
11105 })
11106 }
11107 }
11108 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
11109 }
11110}
11111impl serde::Serialize for RiseCtlListCompactionGroupResponse {
11112 #[allow(deprecated)]
11113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11114 where
11115 S: serde::Serializer,
11116 {
11117 use serde::ser::SerializeStruct;
11118 let mut len = 0;
11119 if self.status.is_some() {
11120 len += 1;
11121 }
11122 if !self.compaction_groups.is_empty() {
11123 len += 1;
11124 }
11125 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
11126 if let Some(v) = self.status.as_ref() {
11127 struct_ser.serialize_field("status", v)?;
11128 }
11129 if !self.compaction_groups.is_empty() {
11130 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
11131 }
11132 struct_ser.end()
11133 }
11134}
11135impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
11136 #[allow(deprecated)]
11137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11138 where
11139 D: serde::Deserializer<'de>,
11140 {
11141 const FIELDS: &[&str] = &[
11142 "status",
11143 "compaction_groups",
11144 "compactionGroups",
11145 ];
11146
11147 #[allow(clippy::enum_variant_names)]
11148 enum GeneratedField {
11149 Status,
11150 CompactionGroups,
11151 }
11152 impl<'de> serde::Deserialize<'de> for GeneratedField {
11153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11154 where
11155 D: serde::Deserializer<'de>,
11156 {
11157 struct GeneratedVisitor;
11158
11159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11160 type Value = GeneratedField;
11161
11162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11163 write!(formatter, "expected one of: {:?}", &FIELDS)
11164 }
11165
11166 #[allow(unused_variables)]
11167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11168 where
11169 E: serde::de::Error,
11170 {
11171 match value {
11172 "status" => Ok(GeneratedField::Status),
11173 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
11174 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11175 }
11176 }
11177 }
11178 deserializer.deserialize_identifier(GeneratedVisitor)
11179 }
11180 }
11181 struct GeneratedVisitor;
11182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11183 type Value = RiseCtlListCompactionGroupResponse;
11184
11185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11186 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
11187 }
11188
11189 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
11190 where
11191 V: serde::de::MapAccess<'de>,
11192 {
11193 let mut status__ = None;
11194 let mut compaction_groups__ = None;
11195 while let Some(k) = map_.next_key()? {
11196 match k {
11197 GeneratedField::Status => {
11198 if status__.is_some() {
11199 return Err(serde::de::Error::duplicate_field("status"));
11200 }
11201 status__ = map_.next_value()?;
11202 }
11203 GeneratedField::CompactionGroups => {
11204 if compaction_groups__.is_some() {
11205 return Err(serde::de::Error::duplicate_field("compactionGroups"));
11206 }
11207 compaction_groups__ = Some(map_.next_value()?);
11208 }
11209 }
11210 }
11211 Ok(RiseCtlListCompactionGroupResponse {
11212 status: status__,
11213 compaction_groups: compaction_groups__.unwrap_or_default(),
11214 })
11215 }
11216 }
11217 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
11218 }
11219}
11220impl serde::Serialize for RiseCtlListCompactionStatusRequest {
11221 #[allow(deprecated)]
11222 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11223 where
11224 S: serde::Serializer,
11225 {
11226 use serde::ser::SerializeStruct;
11227 let len = 0;
11228 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
11229 struct_ser.end()
11230 }
11231}
11232impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
11233 #[allow(deprecated)]
11234 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11235 where
11236 D: serde::Deserializer<'de>,
11237 {
11238 const FIELDS: &[&str] = &[
11239 ];
11240
11241 #[allow(clippy::enum_variant_names)]
11242 enum GeneratedField {
11243 }
11244 impl<'de> serde::Deserialize<'de> for GeneratedField {
11245 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11246 where
11247 D: serde::Deserializer<'de>,
11248 {
11249 struct GeneratedVisitor;
11250
11251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11252 type Value = GeneratedField;
11253
11254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11255 write!(formatter, "expected one of: {:?}", &FIELDS)
11256 }
11257
11258 #[allow(unused_variables)]
11259 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11260 where
11261 E: serde::de::Error,
11262 {
11263 Err(serde::de::Error::unknown_field(value, FIELDS))
11264 }
11265 }
11266 deserializer.deserialize_identifier(GeneratedVisitor)
11267 }
11268 }
11269 struct GeneratedVisitor;
11270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11271 type Value = RiseCtlListCompactionStatusRequest;
11272
11273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11274 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
11275 }
11276
11277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
11278 where
11279 V: serde::de::MapAccess<'de>,
11280 {
11281 while map_.next_key::<GeneratedField>()?.is_some() {
11282 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11283 }
11284 Ok(RiseCtlListCompactionStatusRequest {
11285 })
11286 }
11287 }
11288 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
11289 }
11290}
11291impl serde::Serialize for RiseCtlListCompactionStatusResponse {
11292 #[allow(deprecated)]
11293 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11294 where
11295 S: serde::Serializer,
11296 {
11297 use serde::ser::SerializeStruct;
11298 let mut len = 0;
11299 if !self.compaction_statuses.is_empty() {
11300 len += 1;
11301 }
11302 if !self.task_assignment.is_empty() {
11303 len += 1;
11304 }
11305 if !self.task_progress.is_empty() {
11306 len += 1;
11307 }
11308 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
11309 if !self.compaction_statuses.is_empty() {
11310 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
11311 }
11312 if !self.task_assignment.is_empty() {
11313 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
11314 }
11315 if !self.task_progress.is_empty() {
11316 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
11317 }
11318 struct_ser.end()
11319 }
11320}
11321impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
11322 #[allow(deprecated)]
11323 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11324 where
11325 D: serde::Deserializer<'de>,
11326 {
11327 const FIELDS: &[&str] = &[
11328 "compaction_statuses",
11329 "compactionStatuses",
11330 "task_assignment",
11331 "taskAssignment",
11332 "task_progress",
11333 "taskProgress",
11334 ];
11335
11336 #[allow(clippy::enum_variant_names)]
11337 enum GeneratedField {
11338 CompactionStatuses,
11339 TaskAssignment,
11340 TaskProgress,
11341 }
11342 impl<'de> serde::Deserialize<'de> for GeneratedField {
11343 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11344 where
11345 D: serde::Deserializer<'de>,
11346 {
11347 struct GeneratedVisitor;
11348
11349 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11350 type Value = GeneratedField;
11351
11352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11353 write!(formatter, "expected one of: {:?}", &FIELDS)
11354 }
11355
11356 #[allow(unused_variables)]
11357 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11358 where
11359 E: serde::de::Error,
11360 {
11361 match value {
11362 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
11363 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
11364 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
11365 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11366 }
11367 }
11368 }
11369 deserializer.deserialize_identifier(GeneratedVisitor)
11370 }
11371 }
11372 struct GeneratedVisitor;
11373 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11374 type Value = RiseCtlListCompactionStatusResponse;
11375
11376 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11377 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
11378 }
11379
11380 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
11381 where
11382 V: serde::de::MapAccess<'de>,
11383 {
11384 let mut compaction_statuses__ = None;
11385 let mut task_assignment__ = None;
11386 let mut task_progress__ = None;
11387 while let Some(k) = map_.next_key()? {
11388 match k {
11389 GeneratedField::CompactionStatuses => {
11390 if compaction_statuses__.is_some() {
11391 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
11392 }
11393 compaction_statuses__ = Some(map_.next_value()?);
11394 }
11395 GeneratedField::TaskAssignment => {
11396 if task_assignment__.is_some() {
11397 return Err(serde::de::Error::duplicate_field("taskAssignment"));
11398 }
11399 task_assignment__ = Some(map_.next_value()?);
11400 }
11401 GeneratedField::TaskProgress => {
11402 if task_progress__.is_some() {
11403 return Err(serde::de::Error::duplicate_field("taskProgress"));
11404 }
11405 task_progress__ = Some(map_.next_value()?);
11406 }
11407 }
11408 }
11409 Ok(RiseCtlListCompactionStatusResponse {
11410 compaction_statuses: compaction_statuses__.unwrap_or_default(),
11411 task_assignment: task_assignment__.unwrap_or_default(),
11412 task_progress: task_progress__.unwrap_or_default(),
11413 })
11414 }
11415 }
11416 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
11417 }
11418}
11419impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
11420 #[allow(deprecated)]
11421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11422 where
11423 S: serde::Serializer,
11424 {
11425 use serde::ser::SerializeStruct;
11426 let len = 0;
11427 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
11428 struct_ser.end()
11429 }
11430}
11431impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
11432 #[allow(deprecated)]
11433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11434 where
11435 D: serde::Deserializer<'de>,
11436 {
11437 const FIELDS: &[&str] = &[
11438 ];
11439
11440 #[allow(clippy::enum_variant_names)]
11441 enum GeneratedField {
11442 }
11443 impl<'de> serde::Deserialize<'de> for GeneratedField {
11444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11445 where
11446 D: serde::Deserializer<'de>,
11447 {
11448 struct GeneratedVisitor;
11449
11450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11451 type Value = GeneratedField;
11452
11453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11454 write!(formatter, "expected one of: {:?}", &FIELDS)
11455 }
11456
11457 #[allow(unused_variables)]
11458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11459 where
11460 E: serde::de::Error,
11461 {
11462 Err(serde::de::Error::unknown_field(value, FIELDS))
11463 }
11464 }
11465 deserializer.deserialize_identifier(GeneratedVisitor)
11466 }
11467 }
11468 struct GeneratedVisitor;
11469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11470 type Value = RiseCtlPauseVersionCheckpointRequest;
11471
11472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11473 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
11474 }
11475
11476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
11477 where
11478 V: serde::de::MapAccess<'de>,
11479 {
11480 while map_.next_key::<GeneratedField>()?.is_some() {
11481 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11482 }
11483 Ok(RiseCtlPauseVersionCheckpointRequest {
11484 })
11485 }
11486 }
11487 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11488 }
11489}
11490impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
11491 #[allow(deprecated)]
11492 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11493 where
11494 S: serde::Serializer,
11495 {
11496 use serde::ser::SerializeStruct;
11497 let len = 0;
11498 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
11499 struct_ser.end()
11500 }
11501}
11502impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
11503 #[allow(deprecated)]
11504 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11505 where
11506 D: serde::Deserializer<'de>,
11507 {
11508 const FIELDS: &[&str] = &[
11509 ];
11510
11511 #[allow(clippy::enum_variant_names)]
11512 enum GeneratedField {
11513 }
11514 impl<'de> serde::Deserialize<'de> for GeneratedField {
11515 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11516 where
11517 D: serde::Deserializer<'de>,
11518 {
11519 struct GeneratedVisitor;
11520
11521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11522 type Value = GeneratedField;
11523
11524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11525 write!(formatter, "expected one of: {:?}", &FIELDS)
11526 }
11527
11528 #[allow(unused_variables)]
11529 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11530 where
11531 E: serde::de::Error,
11532 {
11533 Err(serde::de::Error::unknown_field(value, FIELDS))
11534 }
11535 }
11536 deserializer.deserialize_identifier(GeneratedVisitor)
11537 }
11538 }
11539 struct GeneratedVisitor;
11540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11541 type Value = RiseCtlPauseVersionCheckpointResponse;
11542
11543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11544 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
11545 }
11546
11547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
11548 where
11549 V: serde::de::MapAccess<'de>,
11550 {
11551 while map_.next_key::<GeneratedField>()?.is_some() {
11552 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11553 }
11554 Ok(RiseCtlPauseVersionCheckpointResponse {
11555 })
11556 }
11557 }
11558 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11559 }
11560}
11561impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
11562 #[allow(deprecated)]
11563 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11564 where
11565 S: serde::Serializer,
11566 {
11567 use serde::ser::SerializeStruct;
11568 let len = 0;
11569 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
11570 struct_ser.end()
11571 }
11572}
11573impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
11574 #[allow(deprecated)]
11575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11576 where
11577 D: serde::Deserializer<'de>,
11578 {
11579 const FIELDS: &[&str] = &[
11580 ];
11581
11582 #[allow(clippy::enum_variant_names)]
11583 enum GeneratedField {
11584 }
11585 impl<'de> serde::Deserialize<'de> for GeneratedField {
11586 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11587 where
11588 D: serde::Deserializer<'de>,
11589 {
11590 struct GeneratedVisitor;
11591
11592 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11593 type Value = GeneratedField;
11594
11595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11596 write!(formatter, "expected one of: {:?}", &FIELDS)
11597 }
11598
11599 #[allow(unused_variables)]
11600 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11601 where
11602 E: serde::de::Error,
11603 {
11604 Err(serde::de::Error::unknown_field(value, FIELDS))
11605 }
11606 }
11607 deserializer.deserialize_identifier(GeneratedVisitor)
11608 }
11609 }
11610 struct GeneratedVisitor;
11611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11612 type Value = RiseCtlRebuildTableStatsRequest;
11613
11614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11615 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
11616 }
11617
11618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
11619 where
11620 V: serde::de::MapAccess<'de>,
11621 {
11622 while map_.next_key::<GeneratedField>()?.is_some() {
11623 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11624 }
11625 Ok(RiseCtlRebuildTableStatsRequest {
11626 })
11627 }
11628 }
11629 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
11630 }
11631}
11632impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
11633 #[allow(deprecated)]
11634 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11635 where
11636 S: serde::Serializer,
11637 {
11638 use serde::ser::SerializeStruct;
11639 let len = 0;
11640 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
11641 struct_ser.end()
11642 }
11643}
11644impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
11645 #[allow(deprecated)]
11646 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11647 where
11648 D: serde::Deserializer<'de>,
11649 {
11650 const FIELDS: &[&str] = &[
11651 ];
11652
11653 #[allow(clippy::enum_variant_names)]
11654 enum GeneratedField {
11655 }
11656 impl<'de> serde::Deserialize<'de> for GeneratedField {
11657 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11658 where
11659 D: serde::Deserializer<'de>,
11660 {
11661 struct GeneratedVisitor;
11662
11663 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11664 type Value = GeneratedField;
11665
11666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11667 write!(formatter, "expected one of: {:?}", &FIELDS)
11668 }
11669
11670 #[allow(unused_variables)]
11671 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11672 where
11673 E: serde::de::Error,
11674 {
11675 Err(serde::de::Error::unknown_field(value, FIELDS))
11676 }
11677 }
11678 deserializer.deserialize_identifier(GeneratedVisitor)
11679 }
11680 }
11681 struct GeneratedVisitor;
11682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11683 type Value = RiseCtlRebuildTableStatsResponse;
11684
11685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11686 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
11687 }
11688
11689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
11690 where
11691 V: serde::de::MapAccess<'de>,
11692 {
11693 while map_.next_key::<GeneratedField>()?.is_some() {
11694 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11695 }
11696 Ok(RiseCtlRebuildTableStatsResponse {
11697 })
11698 }
11699 }
11700 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
11701 }
11702}
11703impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
11704 #[allow(deprecated)]
11705 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11706 where
11707 S: serde::Serializer,
11708 {
11709 use serde::ser::SerializeStruct;
11710 let len = 0;
11711 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
11712 struct_ser.end()
11713 }
11714}
11715impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
11716 #[allow(deprecated)]
11717 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11718 where
11719 D: serde::Deserializer<'de>,
11720 {
11721 const FIELDS: &[&str] = &[
11722 ];
11723
11724 #[allow(clippy::enum_variant_names)]
11725 enum GeneratedField {
11726 }
11727 impl<'de> serde::Deserialize<'de> for GeneratedField {
11728 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11729 where
11730 D: serde::Deserializer<'de>,
11731 {
11732 struct GeneratedVisitor;
11733
11734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11735 type Value = GeneratedField;
11736
11737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11738 write!(formatter, "expected one of: {:?}", &FIELDS)
11739 }
11740
11741 #[allow(unused_variables)]
11742 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11743 where
11744 E: serde::de::Error,
11745 {
11746 Err(serde::de::Error::unknown_field(value, FIELDS))
11747 }
11748 }
11749 deserializer.deserialize_identifier(GeneratedVisitor)
11750 }
11751 }
11752 struct GeneratedVisitor;
11753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11754 type Value = RiseCtlResumeVersionCheckpointRequest;
11755
11756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11757 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
11758 }
11759
11760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
11761 where
11762 V: serde::de::MapAccess<'de>,
11763 {
11764 while map_.next_key::<GeneratedField>()?.is_some() {
11765 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11766 }
11767 Ok(RiseCtlResumeVersionCheckpointRequest {
11768 })
11769 }
11770 }
11771 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11772 }
11773}
11774impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
11775 #[allow(deprecated)]
11776 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11777 where
11778 S: serde::Serializer,
11779 {
11780 use serde::ser::SerializeStruct;
11781 let len = 0;
11782 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
11783 struct_ser.end()
11784 }
11785}
11786impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
11787 #[allow(deprecated)]
11788 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11789 where
11790 D: serde::Deserializer<'de>,
11791 {
11792 const FIELDS: &[&str] = &[
11793 ];
11794
11795 #[allow(clippy::enum_variant_names)]
11796 enum GeneratedField {
11797 }
11798 impl<'de> serde::Deserialize<'de> for GeneratedField {
11799 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11800 where
11801 D: serde::Deserializer<'de>,
11802 {
11803 struct GeneratedVisitor;
11804
11805 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11806 type Value = GeneratedField;
11807
11808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11809 write!(formatter, "expected one of: {:?}", &FIELDS)
11810 }
11811
11812 #[allow(unused_variables)]
11813 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11814 where
11815 E: serde::de::Error,
11816 {
11817 Err(serde::de::Error::unknown_field(value, FIELDS))
11818 }
11819 }
11820 deserializer.deserialize_identifier(GeneratedVisitor)
11821 }
11822 }
11823 struct GeneratedVisitor;
11824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11825 type Value = RiseCtlResumeVersionCheckpointResponse;
11826
11827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11828 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
11829 }
11830
11831 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
11832 where
11833 V: serde::de::MapAccess<'de>,
11834 {
11835 while map_.next_key::<GeneratedField>()?.is_some() {
11836 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11837 }
11838 Ok(RiseCtlResumeVersionCheckpointResponse {
11839 })
11840 }
11841 }
11842 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11843 }
11844}
11845impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
11846 #[allow(deprecated)]
11847 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11848 where
11849 S: serde::Serializer,
11850 {
11851 use serde::ser::SerializeStruct;
11852 let mut len = 0;
11853 if !self.compaction_group_ids.is_empty() {
11854 len += 1;
11855 }
11856 if !self.configs.is_empty() {
11857 len += 1;
11858 }
11859 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
11860 if !self.compaction_group_ids.is_empty() {
11861 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
11862 }
11863 if !self.configs.is_empty() {
11864 struct_ser.serialize_field("configs", &self.configs)?;
11865 }
11866 struct_ser.end()
11867 }
11868}
11869impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
11870 #[allow(deprecated)]
11871 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11872 where
11873 D: serde::Deserializer<'de>,
11874 {
11875 const FIELDS: &[&str] = &[
11876 "compaction_group_ids",
11877 "compactionGroupIds",
11878 "configs",
11879 ];
11880
11881 #[allow(clippy::enum_variant_names)]
11882 enum GeneratedField {
11883 CompactionGroupIds,
11884 Configs,
11885 }
11886 impl<'de> serde::Deserialize<'de> for GeneratedField {
11887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11888 where
11889 D: serde::Deserializer<'de>,
11890 {
11891 struct GeneratedVisitor;
11892
11893 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11894 type Value = GeneratedField;
11895
11896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11897 write!(formatter, "expected one of: {:?}", &FIELDS)
11898 }
11899
11900 #[allow(unused_variables)]
11901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11902 where
11903 E: serde::de::Error,
11904 {
11905 match value {
11906 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
11907 "configs" => Ok(GeneratedField::Configs),
11908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11909 }
11910 }
11911 }
11912 deserializer.deserialize_identifier(GeneratedVisitor)
11913 }
11914 }
11915 struct GeneratedVisitor;
11916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11917 type Value = RiseCtlUpdateCompactionConfigRequest;
11918
11919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11920 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
11921 }
11922
11923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
11924 where
11925 V: serde::de::MapAccess<'de>,
11926 {
11927 let mut compaction_group_ids__ = None;
11928 let mut configs__ = None;
11929 while let Some(k) = map_.next_key()? {
11930 match k {
11931 GeneratedField::CompactionGroupIds => {
11932 if compaction_group_ids__.is_some() {
11933 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
11934 }
11935 compaction_group_ids__ =
11936 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11937 .into_iter().map(|x| x.0).collect())
11938 ;
11939 }
11940 GeneratedField::Configs => {
11941 if configs__.is_some() {
11942 return Err(serde::de::Error::duplicate_field("configs"));
11943 }
11944 configs__ = Some(map_.next_value()?);
11945 }
11946 }
11947 }
11948 Ok(RiseCtlUpdateCompactionConfigRequest {
11949 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
11950 configs: configs__.unwrap_or_default(),
11951 })
11952 }
11953 }
11954 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
11955 }
11956}
11957impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11958 #[allow(deprecated)]
11959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11960 where
11961 S: serde::Serializer,
11962 {
11963 use serde::ser::SerializeStruct;
11964 let mut len = 0;
11965 if self.level != 0 {
11966 len += 1;
11967 }
11968 if !self.compression_algorithm.is_empty() {
11969 len += 1;
11970 }
11971 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
11972 if self.level != 0 {
11973 struct_ser.serialize_field("level", &self.level)?;
11974 }
11975 if !self.compression_algorithm.is_empty() {
11976 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
11977 }
11978 struct_ser.end()
11979 }
11980}
11981impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11982 #[allow(deprecated)]
11983 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11984 where
11985 D: serde::Deserializer<'de>,
11986 {
11987 const FIELDS: &[&str] = &[
11988 "level",
11989 "compression_algorithm",
11990 "compressionAlgorithm",
11991 ];
11992
11993 #[allow(clippy::enum_variant_names)]
11994 enum GeneratedField {
11995 Level,
11996 CompressionAlgorithm,
11997 }
11998 impl<'de> serde::Deserialize<'de> for GeneratedField {
11999 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12000 where
12001 D: serde::Deserializer<'de>,
12002 {
12003 struct GeneratedVisitor;
12004
12005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12006 type Value = GeneratedField;
12007
12008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12009 write!(formatter, "expected one of: {:?}", &FIELDS)
12010 }
12011
12012 #[allow(unused_variables)]
12013 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12014 where
12015 E: serde::de::Error,
12016 {
12017 match value {
12018 "level" => Ok(GeneratedField::Level),
12019 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12020 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12021 }
12022 }
12023 }
12024 deserializer.deserialize_identifier(GeneratedVisitor)
12025 }
12026 }
12027 struct GeneratedVisitor;
12028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12029 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
12030
12031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12032 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
12033 }
12034
12035 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
12036 where
12037 V: serde::de::MapAccess<'de>,
12038 {
12039 let mut level__ = None;
12040 let mut compression_algorithm__ = None;
12041 while let Some(k) = map_.next_key()? {
12042 match k {
12043 GeneratedField::Level => {
12044 if level__.is_some() {
12045 return Err(serde::de::Error::duplicate_field("level"));
12046 }
12047 level__ =
12048 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12049 ;
12050 }
12051 GeneratedField::CompressionAlgorithm => {
12052 if compression_algorithm__.is_some() {
12053 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12054 }
12055 compression_algorithm__ = Some(map_.next_value()?);
12056 }
12057 }
12058 }
12059 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12060 level: level__.unwrap_or_default(),
12061 compression_algorithm: compression_algorithm__.unwrap_or_default(),
12062 })
12063 }
12064 }
12065 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
12066 }
12067}
12068impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
12069 #[allow(deprecated)]
12070 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12071 where
12072 S: serde::Serializer,
12073 {
12074 use serde::ser::SerializeStruct;
12075 let mut len = 0;
12076 if self.mutable_config.is_some() {
12077 len += 1;
12078 }
12079 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
12080 if let Some(v) = self.mutable_config.as_ref() {
12081 match v {
12082 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
12083 #[allow(clippy::needless_borrow)]
12084 #[allow(clippy::needless_borrows_for_generic_args)]
12085 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
12086 }
12087 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
12088 #[allow(clippy::needless_borrow)]
12089 #[allow(clippy::needless_borrows_for_generic_args)]
12090 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
12091 }
12092 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
12093 #[allow(clippy::needless_borrow)]
12094 #[allow(clippy::needless_borrows_for_generic_args)]
12095 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
12096 }
12097 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
12098 #[allow(clippy::needless_borrow)]
12099 #[allow(clippy::needless_borrows_for_generic_args)]
12100 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
12101 }
12102 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
12103 #[allow(clippy::needless_borrow)]
12104 #[allow(clippy::needless_borrows_for_generic_args)]
12105 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
12106 }
12107 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
12108 #[allow(clippy::needless_borrow)]
12109 #[allow(clippy::needless_borrows_for_generic_args)]
12110 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
12111 }
12112 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
12113 struct_ser.serialize_field("compactionFilterMask", v)?;
12114 }
12115 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
12116 struct_ser.serialize_field("maxSubCompaction", v)?;
12117 }
12118 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
12119 #[allow(clippy::needless_borrow)]
12120 #[allow(clippy::needless_borrows_for_generic_args)]
12121 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
12122 }
12123 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
12124 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
12125 }
12126 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
12127 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
12128 }
12129 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
12130 #[allow(clippy::needless_borrow)]
12131 #[allow(clippy::needless_borrows_for_generic_args)]
12132 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
12133 }
12134 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
12135 #[allow(clippy::needless_borrow)]
12136 #[allow(clippy::needless_borrows_for_generic_args)]
12137 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
12138 }
12139 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
12140 struct_ser.serialize_field("enableEmergencyPicker", v)?;
12141 }
12142 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
12143 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
12144 }
12145 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
12146 struct_ser.serialize_field("compressionAlgorithm", v)?;
12147 }
12148 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
12149 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
12150 }
12151 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
12152 #[allow(clippy::needless_borrow)]
12153 #[allow(clippy::needless_borrows_for_generic_args)]
12154 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
12155 }
12156 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
12157 struct_ser.serialize_field("splitWeightByVnode", v)?;
12158 }
12159 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
12160 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
12161 }
12162 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
12163 #[allow(clippy::needless_borrow)]
12164 #[allow(clippy::needless_borrows_for_generic_args)]
12165 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
12166 }
12167 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
12168 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
12169 }
12170 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
12171 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
12172 }
12173 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
12174 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
12175 }
12176 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
12177 #[allow(clippy::needless_borrow)]
12178 #[allow(clippy::needless_borrows_for_generic_args)]
12179 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
12180 }
12181 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
12182 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
12183 }
12184 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
12185 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
12186 }
12187 }
12188 }
12189 struct_ser.end()
12190 }
12191}
12192impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
12193 #[allow(deprecated)]
12194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12195 where
12196 D: serde::Deserializer<'de>,
12197 {
12198 const FIELDS: &[&str] = &[
12199 "max_bytes_for_level_base",
12200 "maxBytesForLevelBase",
12201 "max_bytes_for_level_multiplier",
12202 "maxBytesForLevelMultiplier",
12203 "max_compaction_bytes",
12204 "maxCompactionBytes",
12205 "sub_level_max_compaction_bytes",
12206 "subLevelMaxCompactionBytes",
12207 "level0_tier_compact_file_number",
12208 "level0TierCompactFileNumber",
12209 "target_file_size_base",
12210 "targetFileSizeBase",
12211 "compaction_filter_mask",
12212 "compactionFilterMask",
12213 "max_sub_compaction",
12214 "maxSubCompaction",
12215 "level0_stop_write_threshold_sub_level_number",
12216 "level0StopWriteThresholdSubLevelNumber",
12217 "level0_sub_level_compact_level_count",
12218 "level0SubLevelCompactLevelCount",
12219 "level0_overlapping_sub_level_compact_level_count",
12220 "level0OverlappingSubLevelCompactLevelCount",
12221 "max_space_reclaim_bytes",
12222 "maxSpaceReclaimBytes",
12223 "level0_max_compact_file_number",
12224 "level0MaxCompactFileNumber",
12225 "enable_emergency_picker",
12226 "enableEmergencyPicker",
12227 "tombstone_reclaim_ratio",
12228 "tombstoneReclaimRatio",
12229 "compression_algorithm",
12230 "compressionAlgorithm",
12231 "max_l0_compact_level_count",
12232 "maxL0CompactLevelCount",
12233 "sst_allowed_trivial_move_min_size",
12234 "sstAllowedTrivialMoveMinSize",
12235 "split_weight_by_vnode",
12236 "splitWeightByVnode",
12237 "disable_auto_group_scheduling",
12238 "disableAutoGroupScheduling",
12239 "max_overlapping_level_size",
12240 "maxOverlappingLevelSize",
12241 "emergency_level0_sst_file_count",
12242 "emergencyLevel0SstFileCount",
12243 "emergency_level0_sub_level_partition",
12244 "emergencyLevel0SubLevelPartition",
12245 "level0_stop_write_threshold_max_sst_count",
12246 "level0StopWriteThresholdMaxSstCount",
12247 "level0_stop_write_threshold_max_size",
12248 "level0StopWriteThresholdMaxSize",
12249 "sst_allowed_trivial_move_max_count",
12250 "sstAllowedTrivialMoveMaxCount",
12251 "enable_optimize_l0_interval_selection",
12252 "enableOptimizeL0IntervalSelection",
12253 ];
12254
12255 #[allow(clippy::enum_variant_names)]
12256 enum GeneratedField {
12257 MaxBytesForLevelBase,
12258 MaxBytesForLevelMultiplier,
12259 MaxCompactionBytes,
12260 SubLevelMaxCompactionBytes,
12261 Level0TierCompactFileNumber,
12262 TargetFileSizeBase,
12263 CompactionFilterMask,
12264 MaxSubCompaction,
12265 Level0StopWriteThresholdSubLevelNumber,
12266 Level0SubLevelCompactLevelCount,
12267 Level0OverlappingSubLevelCompactLevelCount,
12268 MaxSpaceReclaimBytes,
12269 Level0MaxCompactFileNumber,
12270 EnableEmergencyPicker,
12271 TombstoneReclaimRatio,
12272 CompressionAlgorithm,
12273 MaxL0CompactLevelCount,
12274 SstAllowedTrivialMoveMinSize,
12275 SplitWeightByVnode,
12276 DisableAutoGroupScheduling,
12277 MaxOverlappingLevelSize,
12278 EmergencyLevel0SstFileCount,
12279 EmergencyLevel0SubLevelPartition,
12280 Level0StopWriteThresholdMaxSstCount,
12281 Level0StopWriteThresholdMaxSize,
12282 SstAllowedTrivialMoveMaxCount,
12283 EnableOptimizeL0IntervalSelection,
12284 }
12285 impl<'de> serde::Deserialize<'de> for GeneratedField {
12286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12287 where
12288 D: serde::Deserializer<'de>,
12289 {
12290 struct GeneratedVisitor;
12291
12292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12293 type Value = GeneratedField;
12294
12295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12296 write!(formatter, "expected one of: {:?}", &FIELDS)
12297 }
12298
12299 #[allow(unused_variables)]
12300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12301 where
12302 E: serde::de::Error,
12303 {
12304 match value {
12305 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
12306 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
12307 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
12308 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
12309 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
12310 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
12311 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
12312 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
12313 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
12314 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
12315 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
12316 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
12317 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
12318 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
12319 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
12320 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12321 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
12322 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
12323 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
12324 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
12325 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
12326 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
12327 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
12328 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
12329 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
12330 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
12331 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
12332 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12333 }
12334 }
12335 }
12336 deserializer.deserialize_identifier(GeneratedVisitor)
12337 }
12338 }
12339 struct GeneratedVisitor;
12340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12341 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
12342
12343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12344 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
12345 }
12346
12347 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
12348 where
12349 V: serde::de::MapAccess<'de>,
12350 {
12351 let mut mutable_config__ = None;
12352 while let Some(k) = map_.next_key()? {
12353 match k {
12354 GeneratedField::MaxBytesForLevelBase => {
12355 if mutable_config__.is_some() {
12356 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
12357 }
12358 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));
12359 }
12360 GeneratedField::MaxBytesForLevelMultiplier => {
12361 if mutable_config__.is_some() {
12362 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
12363 }
12364 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));
12365 }
12366 GeneratedField::MaxCompactionBytes => {
12367 if mutable_config__.is_some() {
12368 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
12369 }
12370 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));
12371 }
12372 GeneratedField::SubLevelMaxCompactionBytes => {
12373 if mutable_config__.is_some() {
12374 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
12375 }
12376 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));
12377 }
12378 GeneratedField::Level0TierCompactFileNumber => {
12379 if mutable_config__.is_some() {
12380 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
12381 }
12382 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));
12383 }
12384 GeneratedField::TargetFileSizeBase => {
12385 if mutable_config__.is_some() {
12386 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
12387 }
12388 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));
12389 }
12390 GeneratedField::CompactionFilterMask => {
12391 if mutable_config__.is_some() {
12392 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
12393 }
12394 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));
12395 }
12396 GeneratedField::MaxSubCompaction => {
12397 if mutable_config__.is_some() {
12398 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
12399 }
12400 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));
12401 }
12402 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
12403 if mutable_config__.is_some() {
12404 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
12405 }
12406 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));
12407 }
12408 GeneratedField::Level0SubLevelCompactLevelCount => {
12409 if mutable_config__.is_some() {
12410 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
12411 }
12412 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));
12413 }
12414 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
12415 if mutable_config__.is_some() {
12416 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
12417 }
12418 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));
12419 }
12420 GeneratedField::MaxSpaceReclaimBytes => {
12421 if mutable_config__.is_some() {
12422 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
12423 }
12424 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));
12425 }
12426 GeneratedField::Level0MaxCompactFileNumber => {
12427 if mutable_config__.is_some() {
12428 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
12429 }
12430 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));
12431 }
12432 GeneratedField::EnableEmergencyPicker => {
12433 if mutable_config__.is_some() {
12434 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
12435 }
12436 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
12437 }
12438 GeneratedField::TombstoneReclaimRatio => {
12439 if mutable_config__.is_some() {
12440 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
12441 }
12442 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));
12443 }
12444 GeneratedField::CompressionAlgorithm => {
12445 if mutable_config__.is_some() {
12446 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12447 }
12448 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
12449;
12450 }
12451 GeneratedField::MaxL0CompactLevelCount => {
12452 if mutable_config__.is_some() {
12453 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
12454 }
12455 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));
12456 }
12457 GeneratedField::SstAllowedTrivialMoveMinSize => {
12458 if mutable_config__.is_some() {
12459 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
12460 }
12461 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));
12462 }
12463 GeneratedField::SplitWeightByVnode => {
12464 if mutable_config__.is_some() {
12465 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
12466 }
12467 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));
12468 }
12469 GeneratedField::DisableAutoGroupScheduling => {
12470 if mutable_config__.is_some() {
12471 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
12472 }
12473 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
12474 }
12475 GeneratedField::MaxOverlappingLevelSize => {
12476 if mutable_config__.is_some() {
12477 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
12478 }
12479 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));
12480 }
12481 GeneratedField::EmergencyLevel0SstFileCount => {
12482 if mutable_config__.is_some() {
12483 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
12484 }
12485 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));
12486 }
12487 GeneratedField::EmergencyLevel0SubLevelPartition => {
12488 if mutable_config__.is_some() {
12489 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
12490 }
12491 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));
12492 }
12493 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
12494 if mutable_config__.is_some() {
12495 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
12496 }
12497 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));
12498 }
12499 GeneratedField::Level0StopWriteThresholdMaxSize => {
12500 if mutable_config__.is_some() {
12501 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
12502 }
12503 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));
12504 }
12505 GeneratedField::SstAllowedTrivialMoveMaxCount => {
12506 if mutable_config__.is_some() {
12507 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
12508 }
12509 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));
12510 }
12511 GeneratedField::EnableOptimizeL0IntervalSelection => {
12512 if mutable_config__.is_some() {
12513 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
12514 }
12515 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
12516 }
12517 }
12518 }
12519 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
12520 mutable_config: mutable_config__,
12521 })
12522 }
12523 }
12524 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
12525 }
12526}
12527impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
12528 #[allow(deprecated)]
12529 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12530 where
12531 S: serde::Serializer,
12532 {
12533 use serde::ser::SerializeStruct;
12534 let mut len = 0;
12535 if self.status.is_some() {
12536 len += 1;
12537 }
12538 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
12539 if let Some(v) = self.status.as_ref() {
12540 struct_ser.serialize_field("status", v)?;
12541 }
12542 struct_ser.end()
12543 }
12544}
12545impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
12546 #[allow(deprecated)]
12547 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12548 where
12549 D: serde::Deserializer<'de>,
12550 {
12551 const FIELDS: &[&str] = &[
12552 "status",
12553 ];
12554
12555 #[allow(clippy::enum_variant_names)]
12556 enum GeneratedField {
12557 Status,
12558 }
12559 impl<'de> serde::Deserialize<'de> for GeneratedField {
12560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12561 where
12562 D: serde::Deserializer<'de>,
12563 {
12564 struct GeneratedVisitor;
12565
12566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12567 type Value = GeneratedField;
12568
12569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12570 write!(formatter, "expected one of: {:?}", &FIELDS)
12571 }
12572
12573 #[allow(unused_variables)]
12574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12575 where
12576 E: serde::de::Error,
12577 {
12578 match value {
12579 "status" => Ok(GeneratedField::Status),
12580 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12581 }
12582 }
12583 }
12584 deserializer.deserialize_identifier(GeneratedVisitor)
12585 }
12586 }
12587 struct GeneratedVisitor;
12588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12589 type Value = RiseCtlUpdateCompactionConfigResponse;
12590
12591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12592 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
12593 }
12594
12595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
12596 where
12597 V: serde::de::MapAccess<'de>,
12598 {
12599 let mut status__ = None;
12600 while let Some(k) = map_.next_key()? {
12601 match k {
12602 GeneratedField::Status => {
12603 if status__.is_some() {
12604 return Err(serde::de::Error::duplicate_field("status"));
12605 }
12606 status__ = map_.next_value()?;
12607 }
12608 }
12609 }
12610 Ok(RiseCtlUpdateCompactionConfigResponse {
12611 status: status__,
12612 })
12613 }
12614 }
12615 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
12616 }
12617}
12618impl serde::Serialize for SplitCompactionGroupRequest {
12619 #[allow(deprecated)]
12620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12621 where
12622 S: serde::Serializer,
12623 {
12624 use serde::ser::SerializeStruct;
12625 let mut len = 0;
12626 if self.group_id != 0 {
12627 len += 1;
12628 }
12629 if !self.table_ids.is_empty() {
12630 len += 1;
12631 }
12632 if self.partition_vnode_count != 0 {
12633 len += 1;
12634 }
12635 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
12636 if self.group_id != 0 {
12637 #[allow(clippy::needless_borrow)]
12638 #[allow(clippy::needless_borrows_for_generic_args)]
12639 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
12640 }
12641 if !self.table_ids.is_empty() {
12642 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12643 }
12644 if self.partition_vnode_count != 0 {
12645 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
12646 }
12647 struct_ser.end()
12648 }
12649}
12650impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
12651 #[allow(deprecated)]
12652 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12653 where
12654 D: serde::Deserializer<'de>,
12655 {
12656 const FIELDS: &[&str] = &[
12657 "group_id",
12658 "groupId",
12659 "table_ids",
12660 "tableIds",
12661 "partition_vnode_count",
12662 "partitionVnodeCount",
12663 ];
12664
12665 #[allow(clippy::enum_variant_names)]
12666 enum GeneratedField {
12667 GroupId,
12668 TableIds,
12669 PartitionVnodeCount,
12670 }
12671 impl<'de> serde::Deserialize<'de> for GeneratedField {
12672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12673 where
12674 D: serde::Deserializer<'de>,
12675 {
12676 struct GeneratedVisitor;
12677
12678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12679 type Value = GeneratedField;
12680
12681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12682 write!(formatter, "expected one of: {:?}", &FIELDS)
12683 }
12684
12685 #[allow(unused_variables)]
12686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12687 where
12688 E: serde::de::Error,
12689 {
12690 match value {
12691 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
12692 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12693 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
12694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12695 }
12696 }
12697 }
12698 deserializer.deserialize_identifier(GeneratedVisitor)
12699 }
12700 }
12701 struct GeneratedVisitor;
12702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12703 type Value = SplitCompactionGroupRequest;
12704
12705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12706 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
12707 }
12708
12709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
12710 where
12711 V: serde::de::MapAccess<'de>,
12712 {
12713 let mut group_id__ = None;
12714 let mut table_ids__ = None;
12715 let mut partition_vnode_count__ = None;
12716 while let Some(k) = map_.next_key()? {
12717 match k {
12718 GeneratedField::GroupId => {
12719 if group_id__.is_some() {
12720 return Err(serde::de::Error::duplicate_field("groupId"));
12721 }
12722 group_id__ =
12723 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12724 ;
12725 }
12726 GeneratedField::TableIds => {
12727 if table_ids__.is_some() {
12728 return Err(serde::de::Error::duplicate_field("tableIds"));
12729 }
12730 table_ids__ =
12731 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12732 .into_iter().map(|x| x.0).collect())
12733 ;
12734 }
12735 GeneratedField::PartitionVnodeCount => {
12736 if partition_vnode_count__.is_some() {
12737 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
12738 }
12739 partition_vnode_count__ =
12740 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12741 ;
12742 }
12743 }
12744 }
12745 Ok(SplitCompactionGroupRequest {
12746 group_id: group_id__.unwrap_or_default(),
12747 table_ids: table_ids__.unwrap_or_default(),
12748 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
12749 })
12750 }
12751 }
12752 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
12753 }
12754}
12755impl serde::Serialize for SplitCompactionGroupResponse {
12756 #[allow(deprecated)]
12757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12758 where
12759 S: serde::Serializer,
12760 {
12761 use serde::ser::SerializeStruct;
12762 let mut len = 0;
12763 if self.new_group_id != 0 {
12764 len += 1;
12765 }
12766 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
12767 if self.new_group_id != 0 {
12768 #[allow(clippy::needless_borrow)]
12769 #[allow(clippy::needless_borrows_for_generic_args)]
12770 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
12771 }
12772 struct_ser.end()
12773 }
12774}
12775impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
12776 #[allow(deprecated)]
12777 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12778 where
12779 D: serde::Deserializer<'de>,
12780 {
12781 const FIELDS: &[&str] = &[
12782 "new_group_id",
12783 "newGroupId",
12784 ];
12785
12786 #[allow(clippy::enum_variant_names)]
12787 enum GeneratedField {
12788 NewGroupId,
12789 }
12790 impl<'de> serde::Deserialize<'de> for GeneratedField {
12791 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12792 where
12793 D: serde::Deserializer<'de>,
12794 {
12795 struct GeneratedVisitor;
12796
12797 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12798 type Value = GeneratedField;
12799
12800 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12801 write!(formatter, "expected one of: {:?}", &FIELDS)
12802 }
12803
12804 #[allow(unused_variables)]
12805 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12806 where
12807 E: serde::de::Error,
12808 {
12809 match value {
12810 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
12811 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12812 }
12813 }
12814 }
12815 deserializer.deserialize_identifier(GeneratedVisitor)
12816 }
12817 }
12818 struct GeneratedVisitor;
12819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12820 type Value = SplitCompactionGroupResponse;
12821
12822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12823 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
12824 }
12825
12826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
12827 where
12828 V: serde::de::MapAccess<'de>,
12829 {
12830 let mut new_group_id__ = None;
12831 while let Some(k) = map_.next_key()? {
12832 match k {
12833 GeneratedField::NewGroupId => {
12834 if new_group_id__.is_some() {
12835 return Err(serde::de::Error::duplicate_field("newGroupId"));
12836 }
12837 new_group_id__ =
12838 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12839 ;
12840 }
12841 }
12842 }
12843 Ok(SplitCompactionGroupResponse {
12844 new_group_id: new_group_id__.unwrap_or_default(),
12845 })
12846 }
12847 }
12848 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
12849 }
12850}
12851impl serde::Serialize for SstableInfo {
12852 #[allow(deprecated)]
12853 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12854 where
12855 S: serde::Serializer,
12856 {
12857 use serde::ser::SerializeStruct;
12858 let mut len = 0;
12859 if self.object_id != 0 {
12860 len += 1;
12861 }
12862 if self.sst_id != 0 {
12863 len += 1;
12864 }
12865 if self.key_range.is_some() {
12866 len += 1;
12867 }
12868 if self.file_size != 0 {
12869 len += 1;
12870 }
12871 if !self.table_ids.is_empty() {
12872 len += 1;
12873 }
12874 if self.meta_offset != 0 {
12875 len += 1;
12876 }
12877 if self.stale_key_count != 0 {
12878 len += 1;
12879 }
12880 if self.total_key_count != 0 {
12881 len += 1;
12882 }
12883 if self.min_epoch != 0 {
12884 len += 1;
12885 }
12886 if self.max_epoch != 0 {
12887 len += 1;
12888 }
12889 if self.uncompressed_file_size != 0 {
12890 len += 1;
12891 }
12892 if self.range_tombstone_count != 0 {
12893 len += 1;
12894 }
12895 if self.bloom_filter_kind != 0 {
12896 len += 1;
12897 }
12898 if self.sst_size != 0 {
12899 len += 1;
12900 }
12901 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
12902 if self.object_id != 0 {
12903 #[allow(clippy::needless_borrow)]
12904 #[allow(clippy::needless_borrows_for_generic_args)]
12905 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
12906 }
12907 if self.sst_id != 0 {
12908 #[allow(clippy::needless_borrow)]
12909 #[allow(clippy::needless_borrows_for_generic_args)]
12910 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
12911 }
12912 if let Some(v) = self.key_range.as_ref() {
12913 struct_ser.serialize_field("keyRange", v)?;
12914 }
12915 if self.file_size != 0 {
12916 #[allow(clippy::needless_borrow)]
12917 #[allow(clippy::needless_borrows_for_generic_args)]
12918 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
12919 }
12920 if !self.table_ids.is_empty() {
12921 struct_ser.serialize_field("tableIds", &self.table_ids)?;
12922 }
12923 if self.meta_offset != 0 {
12924 #[allow(clippy::needless_borrow)]
12925 #[allow(clippy::needless_borrows_for_generic_args)]
12926 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
12927 }
12928 if self.stale_key_count != 0 {
12929 #[allow(clippy::needless_borrow)]
12930 #[allow(clippy::needless_borrows_for_generic_args)]
12931 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
12932 }
12933 if self.total_key_count != 0 {
12934 #[allow(clippy::needless_borrow)]
12935 #[allow(clippy::needless_borrows_for_generic_args)]
12936 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
12937 }
12938 if self.min_epoch != 0 {
12939 #[allow(clippy::needless_borrow)]
12940 #[allow(clippy::needless_borrows_for_generic_args)]
12941 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
12942 }
12943 if self.max_epoch != 0 {
12944 #[allow(clippy::needless_borrow)]
12945 #[allow(clippy::needless_borrows_for_generic_args)]
12946 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
12947 }
12948 if self.uncompressed_file_size != 0 {
12949 #[allow(clippy::needless_borrow)]
12950 #[allow(clippy::needless_borrows_for_generic_args)]
12951 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
12952 }
12953 if self.range_tombstone_count != 0 {
12954 #[allow(clippy::needless_borrow)]
12955 #[allow(clippy::needless_borrows_for_generic_args)]
12956 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
12957 }
12958 if self.bloom_filter_kind != 0 {
12959 let v = BloomFilterType::try_from(self.bloom_filter_kind)
12960 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
12961 struct_ser.serialize_field("bloomFilterKind", &v)?;
12962 }
12963 if self.sst_size != 0 {
12964 #[allow(clippy::needless_borrow)]
12965 #[allow(clippy::needless_borrows_for_generic_args)]
12966 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
12967 }
12968 struct_ser.end()
12969 }
12970}
12971impl<'de> serde::Deserialize<'de> for SstableInfo {
12972 #[allow(deprecated)]
12973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12974 where
12975 D: serde::Deserializer<'de>,
12976 {
12977 const FIELDS: &[&str] = &[
12978 "object_id",
12979 "objectId",
12980 "sst_id",
12981 "sstId",
12982 "key_range",
12983 "keyRange",
12984 "file_size",
12985 "fileSize",
12986 "table_ids",
12987 "tableIds",
12988 "meta_offset",
12989 "metaOffset",
12990 "stale_key_count",
12991 "staleKeyCount",
12992 "total_key_count",
12993 "totalKeyCount",
12994 "min_epoch",
12995 "minEpoch",
12996 "max_epoch",
12997 "maxEpoch",
12998 "uncompressed_file_size",
12999 "uncompressedFileSize",
13000 "range_tombstone_count",
13001 "rangeTombstoneCount",
13002 "bloom_filter_kind",
13003 "bloomFilterKind",
13004 "sst_size",
13005 "sstSize",
13006 ];
13007
13008 #[allow(clippy::enum_variant_names)]
13009 enum GeneratedField {
13010 ObjectId,
13011 SstId,
13012 KeyRange,
13013 FileSize,
13014 TableIds,
13015 MetaOffset,
13016 StaleKeyCount,
13017 TotalKeyCount,
13018 MinEpoch,
13019 MaxEpoch,
13020 UncompressedFileSize,
13021 RangeTombstoneCount,
13022 BloomFilterKind,
13023 SstSize,
13024 }
13025 impl<'de> serde::Deserialize<'de> for GeneratedField {
13026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13027 where
13028 D: serde::Deserializer<'de>,
13029 {
13030 struct GeneratedVisitor;
13031
13032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13033 type Value = GeneratedField;
13034
13035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13036 write!(formatter, "expected one of: {:?}", &FIELDS)
13037 }
13038
13039 #[allow(unused_variables)]
13040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13041 where
13042 E: serde::de::Error,
13043 {
13044 match value {
13045 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
13046 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
13047 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
13048 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
13049 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13050 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
13051 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
13052 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
13053 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
13054 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
13055 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
13056 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
13057 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
13058 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
13059 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13060 }
13061 }
13062 }
13063 deserializer.deserialize_identifier(GeneratedVisitor)
13064 }
13065 }
13066 struct GeneratedVisitor;
13067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13068 type Value = SstableInfo;
13069
13070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13071 formatter.write_str("struct hummock.SstableInfo")
13072 }
13073
13074 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
13075 where
13076 V: serde::de::MapAccess<'de>,
13077 {
13078 let mut object_id__ = None;
13079 let mut sst_id__ = None;
13080 let mut key_range__ = None;
13081 let mut file_size__ = None;
13082 let mut table_ids__ = None;
13083 let mut meta_offset__ = None;
13084 let mut stale_key_count__ = None;
13085 let mut total_key_count__ = None;
13086 let mut min_epoch__ = None;
13087 let mut max_epoch__ = None;
13088 let mut uncompressed_file_size__ = None;
13089 let mut range_tombstone_count__ = None;
13090 let mut bloom_filter_kind__ = None;
13091 let mut sst_size__ = None;
13092 while let Some(k) = map_.next_key()? {
13093 match k {
13094 GeneratedField::ObjectId => {
13095 if object_id__.is_some() {
13096 return Err(serde::de::Error::duplicate_field("objectId"));
13097 }
13098 object_id__ =
13099 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13100 ;
13101 }
13102 GeneratedField::SstId => {
13103 if sst_id__.is_some() {
13104 return Err(serde::de::Error::duplicate_field("sstId"));
13105 }
13106 sst_id__ =
13107 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13108 ;
13109 }
13110 GeneratedField::KeyRange => {
13111 if key_range__.is_some() {
13112 return Err(serde::de::Error::duplicate_field("keyRange"));
13113 }
13114 key_range__ = map_.next_value()?;
13115 }
13116 GeneratedField::FileSize => {
13117 if file_size__.is_some() {
13118 return Err(serde::de::Error::duplicate_field("fileSize"));
13119 }
13120 file_size__ =
13121 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13122 ;
13123 }
13124 GeneratedField::TableIds => {
13125 if table_ids__.is_some() {
13126 return Err(serde::de::Error::duplicate_field("tableIds"));
13127 }
13128 table_ids__ =
13129 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13130 .into_iter().map(|x| x.0).collect())
13131 ;
13132 }
13133 GeneratedField::MetaOffset => {
13134 if meta_offset__.is_some() {
13135 return Err(serde::de::Error::duplicate_field("metaOffset"));
13136 }
13137 meta_offset__ =
13138 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13139 ;
13140 }
13141 GeneratedField::StaleKeyCount => {
13142 if stale_key_count__.is_some() {
13143 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
13144 }
13145 stale_key_count__ =
13146 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13147 ;
13148 }
13149 GeneratedField::TotalKeyCount => {
13150 if total_key_count__.is_some() {
13151 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
13152 }
13153 total_key_count__ =
13154 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13155 ;
13156 }
13157 GeneratedField::MinEpoch => {
13158 if min_epoch__.is_some() {
13159 return Err(serde::de::Error::duplicate_field("minEpoch"));
13160 }
13161 min_epoch__ =
13162 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13163 ;
13164 }
13165 GeneratedField::MaxEpoch => {
13166 if max_epoch__.is_some() {
13167 return Err(serde::de::Error::duplicate_field("maxEpoch"));
13168 }
13169 max_epoch__ =
13170 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13171 ;
13172 }
13173 GeneratedField::UncompressedFileSize => {
13174 if uncompressed_file_size__.is_some() {
13175 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
13176 }
13177 uncompressed_file_size__ =
13178 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13179 ;
13180 }
13181 GeneratedField::RangeTombstoneCount => {
13182 if range_tombstone_count__.is_some() {
13183 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
13184 }
13185 range_tombstone_count__ =
13186 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13187 ;
13188 }
13189 GeneratedField::BloomFilterKind => {
13190 if bloom_filter_kind__.is_some() {
13191 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
13192 }
13193 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
13194 }
13195 GeneratedField::SstSize => {
13196 if sst_size__.is_some() {
13197 return Err(serde::de::Error::duplicate_field("sstSize"));
13198 }
13199 sst_size__ =
13200 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13201 ;
13202 }
13203 }
13204 }
13205 Ok(SstableInfo {
13206 object_id: object_id__.unwrap_or_default(),
13207 sst_id: sst_id__.unwrap_or_default(),
13208 key_range: key_range__,
13209 file_size: file_size__.unwrap_or_default(),
13210 table_ids: table_ids__.unwrap_or_default(),
13211 meta_offset: meta_offset__.unwrap_or_default(),
13212 stale_key_count: stale_key_count__.unwrap_or_default(),
13213 total_key_count: total_key_count__.unwrap_or_default(),
13214 min_epoch: min_epoch__.unwrap_or_default(),
13215 max_epoch: max_epoch__.unwrap_or_default(),
13216 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
13217 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
13218 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
13219 sst_size: sst_size__.unwrap_or_default(),
13220 })
13221 }
13222 }
13223 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
13224 }
13225}
13226impl serde::Serialize for StateTableInfo {
13227 #[allow(deprecated)]
13228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13229 where
13230 S: serde::Serializer,
13231 {
13232 use serde::ser::SerializeStruct;
13233 let mut len = 0;
13234 if self.committed_epoch != 0 {
13235 len += 1;
13236 }
13237 if self.compaction_group_id != 0 {
13238 len += 1;
13239 }
13240 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
13241 if self.committed_epoch != 0 {
13242 #[allow(clippy::needless_borrow)]
13243 #[allow(clippy::needless_borrows_for_generic_args)]
13244 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13245 }
13246 if self.compaction_group_id != 0 {
13247 #[allow(clippy::needless_borrow)]
13248 #[allow(clippy::needless_borrows_for_generic_args)]
13249 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13250 }
13251 struct_ser.end()
13252 }
13253}
13254impl<'de> serde::Deserialize<'de> for StateTableInfo {
13255 #[allow(deprecated)]
13256 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13257 where
13258 D: serde::Deserializer<'de>,
13259 {
13260 const FIELDS: &[&str] = &[
13261 "committed_epoch",
13262 "committedEpoch",
13263 "compaction_group_id",
13264 "compactionGroupId",
13265 ];
13266
13267 #[allow(clippy::enum_variant_names)]
13268 enum GeneratedField {
13269 CommittedEpoch,
13270 CompactionGroupId,
13271 }
13272 impl<'de> serde::Deserialize<'de> for GeneratedField {
13273 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13274 where
13275 D: serde::Deserializer<'de>,
13276 {
13277 struct GeneratedVisitor;
13278
13279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13280 type Value = GeneratedField;
13281
13282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13283 write!(formatter, "expected one of: {:?}", &FIELDS)
13284 }
13285
13286 #[allow(unused_variables)]
13287 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13288 where
13289 E: serde::de::Error,
13290 {
13291 match value {
13292 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13293 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13295 }
13296 }
13297 }
13298 deserializer.deserialize_identifier(GeneratedVisitor)
13299 }
13300 }
13301 struct GeneratedVisitor;
13302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13303 type Value = StateTableInfo;
13304
13305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13306 formatter.write_str("struct hummock.StateTableInfo")
13307 }
13308
13309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
13310 where
13311 V: serde::de::MapAccess<'de>,
13312 {
13313 let mut committed_epoch__ = None;
13314 let mut compaction_group_id__ = None;
13315 while let Some(k) = map_.next_key()? {
13316 match k {
13317 GeneratedField::CommittedEpoch => {
13318 if committed_epoch__.is_some() {
13319 return Err(serde::de::Error::duplicate_field("committedEpoch"));
13320 }
13321 committed_epoch__ =
13322 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13323 ;
13324 }
13325 GeneratedField::CompactionGroupId => {
13326 if compaction_group_id__.is_some() {
13327 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
13328 }
13329 compaction_group_id__ =
13330 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13331 ;
13332 }
13333 }
13334 }
13335 Ok(StateTableInfo {
13336 committed_epoch: committed_epoch__.unwrap_or_default(),
13337 compaction_group_id: compaction_group_id__.unwrap_or_default(),
13338 })
13339 }
13340 }
13341 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
13342 }
13343}
13344impl serde::Serialize for StateTableInfoDelta {
13345 #[allow(deprecated)]
13346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13347 where
13348 S: serde::Serializer,
13349 {
13350 use serde::ser::SerializeStruct;
13351 let mut len = 0;
13352 if self.committed_epoch != 0 {
13353 len += 1;
13354 }
13355 if self.compaction_group_id != 0 {
13356 len += 1;
13357 }
13358 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
13359 if self.committed_epoch != 0 {
13360 #[allow(clippy::needless_borrow)]
13361 #[allow(clippy::needless_borrows_for_generic_args)]
13362 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13363 }
13364 if self.compaction_group_id != 0 {
13365 #[allow(clippy::needless_borrow)]
13366 #[allow(clippy::needless_borrows_for_generic_args)]
13367 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13368 }
13369 struct_ser.end()
13370 }
13371}
13372impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
13373 #[allow(deprecated)]
13374 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13375 where
13376 D: serde::Deserializer<'de>,
13377 {
13378 const FIELDS: &[&str] = &[
13379 "committed_epoch",
13380 "committedEpoch",
13381 "compaction_group_id",
13382 "compactionGroupId",
13383 ];
13384
13385 #[allow(clippy::enum_variant_names)]
13386 enum GeneratedField {
13387 CommittedEpoch,
13388 CompactionGroupId,
13389 }
13390 impl<'de> serde::Deserialize<'de> for GeneratedField {
13391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13392 where
13393 D: serde::Deserializer<'de>,
13394 {
13395 struct GeneratedVisitor;
13396
13397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13398 type Value = GeneratedField;
13399
13400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13401 write!(formatter, "expected one of: {:?}", &FIELDS)
13402 }
13403
13404 #[allow(unused_variables)]
13405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13406 where
13407 E: serde::de::Error,
13408 {
13409 match value {
13410 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13411 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13412 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13413 }
13414 }
13415 }
13416 deserializer.deserialize_identifier(GeneratedVisitor)
13417 }
13418 }
13419 struct GeneratedVisitor;
13420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13421 type Value = StateTableInfoDelta;
13422
13423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13424 formatter.write_str("struct hummock.StateTableInfoDelta")
13425 }
13426
13427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
13428 where
13429 V: serde::de::MapAccess<'de>,
13430 {
13431 let mut committed_epoch__ = None;
13432 let mut compaction_group_id__ = None;
13433 while let Some(k) = map_.next_key()? {
13434 match k {
13435 GeneratedField::CommittedEpoch => {
13436 if committed_epoch__.is_some() {
13437 return Err(serde::de::Error::duplicate_field("committedEpoch"));
13438 }
13439 committed_epoch__ =
13440 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13441 ;
13442 }
13443 GeneratedField::CompactionGroupId => {
13444 if compaction_group_id__.is_some() {
13445 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
13446 }
13447 compaction_group_id__ =
13448 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13449 ;
13450 }
13451 }
13452 }
13453 Ok(StateTableInfoDelta {
13454 committed_epoch: committed_epoch__.unwrap_or_default(),
13455 compaction_group_id: compaction_group_id__.unwrap_or_default(),
13456 })
13457 }
13458 }
13459 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
13460 }
13461}
13462impl serde::Serialize for SubscribeCompactionEventRequest {
13463 #[allow(deprecated)]
13464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13465 where
13466 S: serde::Serializer,
13467 {
13468 use serde::ser::SerializeStruct;
13469 let mut len = 0;
13470 if self.create_at != 0 {
13471 len += 1;
13472 }
13473 if self.event.is_some() {
13474 len += 1;
13475 }
13476 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
13477 if self.create_at != 0 {
13478 #[allow(clippy::needless_borrow)]
13479 #[allow(clippy::needless_borrows_for_generic_args)]
13480 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
13481 }
13482 if let Some(v) = self.event.as_ref() {
13483 match v {
13484 subscribe_compaction_event_request::Event::Register(v) => {
13485 struct_ser.serialize_field("register", v)?;
13486 }
13487 subscribe_compaction_event_request::Event::PullTask(v) => {
13488 struct_ser.serialize_field("pullTask", v)?;
13489 }
13490 subscribe_compaction_event_request::Event::ReportTask(v) => {
13491 struct_ser.serialize_field("reportTask", v)?;
13492 }
13493 subscribe_compaction_event_request::Event::HeartBeat(v) => {
13494 struct_ser.serialize_field("heartBeat", v)?;
13495 }
13496 }
13497 }
13498 struct_ser.end()
13499 }
13500}
13501impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
13502 #[allow(deprecated)]
13503 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13504 where
13505 D: serde::Deserializer<'de>,
13506 {
13507 const FIELDS: &[&str] = &[
13508 "create_at",
13509 "createAt",
13510 "register",
13511 "pull_task",
13512 "pullTask",
13513 "report_task",
13514 "reportTask",
13515 "heart_beat",
13516 "heartBeat",
13517 ];
13518
13519 #[allow(clippy::enum_variant_names)]
13520 enum GeneratedField {
13521 CreateAt,
13522 Register,
13523 PullTask,
13524 ReportTask,
13525 HeartBeat,
13526 }
13527 impl<'de> serde::Deserialize<'de> for GeneratedField {
13528 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13529 where
13530 D: serde::Deserializer<'de>,
13531 {
13532 struct GeneratedVisitor;
13533
13534 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13535 type Value = GeneratedField;
13536
13537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13538 write!(formatter, "expected one of: {:?}", &FIELDS)
13539 }
13540
13541 #[allow(unused_variables)]
13542 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13543 where
13544 E: serde::de::Error,
13545 {
13546 match value {
13547 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
13548 "register" => Ok(GeneratedField::Register),
13549 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
13550 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
13551 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
13552 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13553 }
13554 }
13555 }
13556 deserializer.deserialize_identifier(GeneratedVisitor)
13557 }
13558 }
13559 struct GeneratedVisitor;
13560 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13561 type Value = SubscribeCompactionEventRequest;
13562
13563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13564 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
13565 }
13566
13567 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
13568 where
13569 V: serde::de::MapAccess<'de>,
13570 {
13571 let mut create_at__ = None;
13572 let mut event__ = None;
13573 while let Some(k) = map_.next_key()? {
13574 match k {
13575 GeneratedField::CreateAt => {
13576 if create_at__.is_some() {
13577 return Err(serde::de::Error::duplicate_field("createAt"));
13578 }
13579 create_at__ =
13580 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13581 ;
13582 }
13583 GeneratedField::Register => {
13584 if event__.is_some() {
13585 return Err(serde::de::Error::duplicate_field("register"));
13586 }
13587 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
13588;
13589 }
13590 GeneratedField::PullTask => {
13591 if event__.is_some() {
13592 return Err(serde::de::Error::duplicate_field("pullTask"));
13593 }
13594 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
13595;
13596 }
13597 GeneratedField::ReportTask => {
13598 if event__.is_some() {
13599 return Err(serde::de::Error::duplicate_field("reportTask"));
13600 }
13601 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
13602;
13603 }
13604 GeneratedField::HeartBeat => {
13605 if event__.is_some() {
13606 return Err(serde::de::Error::duplicate_field("heartBeat"));
13607 }
13608 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
13609;
13610 }
13611 }
13612 }
13613 Ok(SubscribeCompactionEventRequest {
13614 create_at: create_at__.unwrap_or_default(),
13615 event: event__,
13616 })
13617 }
13618 }
13619 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
13620 }
13621}
13622impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
13623 #[allow(deprecated)]
13624 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13625 where
13626 S: serde::Serializer,
13627 {
13628 use serde::ser::SerializeStruct;
13629 let mut len = 0;
13630 if !self.progress.is_empty() {
13631 len += 1;
13632 }
13633 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
13634 if !self.progress.is_empty() {
13635 struct_ser.serialize_field("progress", &self.progress)?;
13636 }
13637 struct_ser.end()
13638 }
13639}
13640impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
13641 #[allow(deprecated)]
13642 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13643 where
13644 D: serde::Deserializer<'de>,
13645 {
13646 const FIELDS: &[&str] = &[
13647 "progress",
13648 ];
13649
13650 #[allow(clippy::enum_variant_names)]
13651 enum GeneratedField {
13652 Progress,
13653 }
13654 impl<'de> serde::Deserialize<'de> for GeneratedField {
13655 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13656 where
13657 D: serde::Deserializer<'de>,
13658 {
13659 struct GeneratedVisitor;
13660
13661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13662 type Value = GeneratedField;
13663
13664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13665 write!(formatter, "expected one of: {:?}", &FIELDS)
13666 }
13667
13668 #[allow(unused_variables)]
13669 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13670 where
13671 E: serde::de::Error,
13672 {
13673 match value {
13674 "progress" => Ok(GeneratedField::Progress),
13675 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13676 }
13677 }
13678 }
13679 deserializer.deserialize_identifier(GeneratedVisitor)
13680 }
13681 }
13682 struct GeneratedVisitor;
13683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13684 type Value = subscribe_compaction_event_request::HeartBeat;
13685
13686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13687 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
13688 }
13689
13690 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
13691 where
13692 V: serde::de::MapAccess<'de>,
13693 {
13694 let mut progress__ = None;
13695 while let Some(k) = map_.next_key()? {
13696 match k {
13697 GeneratedField::Progress => {
13698 if progress__.is_some() {
13699 return Err(serde::de::Error::duplicate_field("progress"));
13700 }
13701 progress__ = Some(map_.next_value()?);
13702 }
13703 }
13704 }
13705 Ok(subscribe_compaction_event_request::HeartBeat {
13706 progress: progress__.unwrap_or_default(),
13707 })
13708 }
13709 }
13710 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
13711 }
13712}
13713impl serde::Serialize for subscribe_compaction_event_request::PullTask {
13714 #[allow(deprecated)]
13715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13716 where
13717 S: serde::Serializer,
13718 {
13719 use serde::ser::SerializeStruct;
13720 let mut len = 0;
13721 if self.pull_task_count != 0 {
13722 len += 1;
13723 }
13724 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
13725 if self.pull_task_count != 0 {
13726 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
13727 }
13728 struct_ser.end()
13729 }
13730}
13731impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
13732 #[allow(deprecated)]
13733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13734 where
13735 D: serde::Deserializer<'de>,
13736 {
13737 const FIELDS: &[&str] = &[
13738 "pull_task_count",
13739 "pullTaskCount",
13740 ];
13741
13742 #[allow(clippy::enum_variant_names)]
13743 enum GeneratedField {
13744 PullTaskCount,
13745 }
13746 impl<'de> serde::Deserialize<'de> for GeneratedField {
13747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13748 where
13749 D: serde::Deserializer<'de>,
13750 {
13751 struct GeneratedVisitor;
13752
13753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13754 type Value = GeneratedField;
13755
13756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13757 write!(formatter, "expected one of: {:?}", &FIELDS)
13758 }
13759
13760 #[allow(unused_variables)]
13761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13762 where
13763 E: serde::de::Error,
13764 {
13765 match value {
13766 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
13767 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13768 }
13769 }
13770 }
13771 deserializer.deserialize_identifier(GeneratedVisitor)
13772 }
13773 }
13774 struct GeneratedVisitor;
13775 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13776 type Value = subscribe_compaction_event_request::PullTask;
13777
13778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13779 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
13780 }
13781
13782 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
13783 where
13784 V: serde::de::MapAccess<'de>,
13785 {
13786 let mut pull_task_count__ = None;
13787 while let Some(k) = map_.next_key()? {
13788 match k {
13789 GeneratedField::PullTaskCount => {
13790 if pull_task_count__.is_some() {
13791 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
13792 }
13793 pull_task_count__ =
13794 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13795 ;
13796 }
13797 }
13798 }
13799 Ok(subscribe_compaction_event_request::PullTask {
13800 pull_task_count: pull_task_count__.unwrap_or_default(),
13801 })
13802 }
13803 }
13804 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
13805 }
13806}
13807impl serde::Serialize for subscribe_compaction_event_request::Register {
13808 #[allow(deprecated)]
13809 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13810 where
13811 S: serde::Serializer,
13812 {
13813 use serde::ser::SerializeStruct;
13814 let mut len = 0;
13815 if self.context_id != 0 {
13816 len += 1;
13817 }
13818 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
13819 if self.context_id != 0 {
13820 struct_ser.serialize_field("contextId", &self.context_id)?;
13821 }
13822 struct_ser.end()
13823 }
13824}
13825impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
13826 #[allow(deprecated)]
13827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13828 where
13829 D: serde::Deserializer<'de>,
13830 {
13831 const FIELDS: &[&str] = &[
13832 "context_id",
13833 "contextId",
13834 ];
13835
13836 #[allow(clippy::enum_variant_names)]
13837 enum GeneratedField {
13838 ContextId,
13839 }
13840 impl<'de> serde::Deserialize<'de> for GeneratedField {
13841 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13842 where
13843 D: serde::Deserializer<'de>,
13844 {
13845 struct GeneratedVisitor;
13846
13847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13848 type Value = GeneratedField;
13849
13850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13851 write!(formatter, "expected one of: {:?}", &FIELDS)
13852 }
13853
13854 #[allow(unused_variables)]
13855 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13856 where
13857 E: serde::de::Error,
13858 {
13859 match value {
13860 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
13861 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13862 }
13863 }
13864 }
13865 deserializer.deserialize_identifier(GeneratedVisitor)
13866 }
13867 }
13868 struct GeneratedVisitor;
13869 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13870 type Value = subscribe_compaction_event_request::Register;
13871
13872 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13873 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
13874 }
13875
13876 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
13877 where
13878 V: serde::de::MapAccess<'de>,
13879 {
13880 let mut context_id__ = None;
13881 while let Some(k) = map_.next_key()? {
13882 match k {
13883 GeneratedField::ContextId => {
13884 if context_id__.is_some() {
13885 return Err(serde::de::Error::duplicate_field("contextId"));
13886 }
13887 context_id__ =
13888 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13889 ;
13890 }
13891 }
13892 }
13893 Ok(subscribe_compaction_event_request::Register {
13894 context_id: context_id__.unwrap_or_default(),
13895 })
13896 }
13897 }
13898 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
13899 }
13900}
13901impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
13902 #[allow(deprecated)]
13903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13904 where
13905 S: serde::Serializer,
13906 {
13907 use serde::ser::SerializeStruct;
13908 let mut len = 0;
13909 if !self.table_stats_change.is_empty() {
13910 len += 1;
13911 }
13912 if self.task_id != 0 {
13913 len += 1;
13914 }
13915 if self.task_status != 0 {
13916 len += 1;
13917 }
13918 if !self.sorted_output_ssts.is_empty() {
13919 len += 1;
13920 }
13921 if !self.object_timestamps.is_empty() {
13922 len += 1;
13923 }
13924 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
13925 if !self.table_stats_change.is_empty() {
13926 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
13927 }
13928 if self.task_id != 0 {
13929 #[allow(clippy::needless_borrow)]
13930 #[allow(clippy::needless_borrows_for_generic_args)]
13931 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
13932 }
13933 if self.task_status != 0 {
13934 let v = compact_task::TaskStatus::try_from(self.task_status)
13935 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
13936 struct_ser.serialize_field("taskStatus", &v)?;
13937 }
13938 if !self.sorted_output_ssts.is_empty() {
13939 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
13940 }
13941 if !self.object_timestamps.is_empty() {
13942 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
13943 .map(|(k, v)| (k, v.to_string())).collect();
13944 struct_ser.serialize_field("objectTimestamps", &v)?;
13945 }
13946 struct_ser.end()
13947 }
13948}
13949impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
13950 #[allow(deprecated)]
13951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13952 where
13953 D: serde::Deserializer<'de>,
13954 {
13955 const FIELDS: &[&str] = &[
13956 "table_stats_change",
13957 "tableStatsChange",
13958 "task_id",
13959 "taskId",
13960 "task_status",
13961 "taskStatus",
13962 "sorted_output_ssts",
13963 "sortedOutputSsts",
13964 "object_timestamps",
13965 "objectTimestamps",
13966 ];
13967
13968 #[allow(clippy::enum_variant_names)]
13969 enum GeneratedField {
13970 TableStatsChange,
13971 TaskId,
13972 TaskStatus,
13973 SortedOutputSsts,
13974 ObjectTimestamps,
13975 }
13976 impl<'de> serde::Deserialize<'de> for GeneratedField {
13977 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13978 where
13979 D: serde::Deserializer<'de>,
13980 {
13981 struct GeneratedVisitor;
13982
13983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13984 type Value = GeneratedField;
13985
13986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13987 write!(formatter, "expected one of: {:?}", &FIELDS)
13988 }
13989
13990 #[allow(unused_variables)]
13991 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13992 where
13993 E: serde::de::Error,
13994 {
13995 match value {
13996 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
13997 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
13998 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
13999 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
14000 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
14001 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14002 }
14003 }
14004 }
14005 deserializer.deserialize_identifier(GeneratedVisitor)
14006 }
14007 }
14008 struct GeneratedVisitor;
14009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14010 type Value = subscribe_compaction_event_request::ReportTask;
14011
14012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14013 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
14014 }
14015
14016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
14017 where
14018 V: serde::de::MapAccess<'de>,
14019 {
14020 let mut table_stats_change__ = None;
14021 let mut task_id__ = None;
14022 let mut task_status__ = None;
14023 let mut sorted_output_ssts__ = None;
14024 let mut object_timestamps__ = None;
14025 while let Some(k) = map_.next_key()? {
14026 match k {
14027 GeneratedField::TableStatsChange => {
14028 if table_stats_change__.is_some() {
14029 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
14030 }
14031 table_stats_change__ = Some(
14032 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14033 .into_iter().map(|(k,v)| (k.0, v)).collect()
14034 );
14035 }
14036 GeneratedField::TaskId => {
14037 if task_id__.is_some() {
14038 return Err(serde::de::Error::duplicate_field("taskId"));
14039 }
14040 task_id__ =
14041 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14042 ;
14043 }
14044 GeneratedField::TaskStatus => {
14045 if task_status__.is_some() {
14046 return Err(serde::de::Error::duplicate_field("taskStatus"));
14047 }
14048 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
14049 }
14050 GeneratedField::SortedOutputSsts => {
14051 if sorted_output_ssts__.is_some() {
14052 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
14053 }
14054 sorted_output_ssts__ = Some(map_.next_value()?);
14055 }
14056 GeneratedField::ObjectTimestamps => {
14057 if object_timestamps__.is_some() {
14058 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
14059 }
14060 object_timestamps__ = Some(
14061 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14062 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
14063 );
14064 }
14065 }
14066 }
14067 Ok(subscribe_compaction_event_request::ReportTask {
14068 table_stats_change: table_stats_change__.unwrap_or_default(),
14069 task_id: task_id__.unwrap_or_default(),
14070 task_status: task_status__.unwrap_or_default(),
14071 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
14072 object_timestamps: object_timestamps__.unwrap_or_default(),
14073 })
14074 }
14075 }
14076 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
14077 }
14078}
14079impl serde::Serialize for SubscribeCompactionEventResponse {
14080 #[allow(deprecated)]
14081 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14082 where
14083 S: serde::Serializer,
14084 {
14085 use serde::ser::SerializeStruct;
14086 let mut len = 0;
14087 if self.create_at != 0 {
14088 len += 1;
14089 }
14090 if self.event.is_some() {
14091 len += 1;
14092 }
14093 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
14094 if self.create_at != 0 {
14095 #[allow(clippy::needless_borrow)]
14096 #[allow(clippy::needless_borrows_for_generic_args)]
14097 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14098 }
14099 if let Some(v) = self.event.as_ref() {
14100 match v {
14101 subscribe_compaction_event_response::Event::CompactTask(v) => {
14102 struct_ser.serialize_field("compactTask", v)?;
14103 }
14104 subscribe_compaction_event_response::Event::VacuumTask(v) => {
14105 struct_ser.serialize_field("vacuumTask", v)?;
14106 }
14107 subscribe_compaction_event_response::Event::FullScanTask(v) => {
14108 struct_ser.serialize_field("fullScanTask", v)?;
14109 }
14110 subscribe_compaction_event_response::Event::ValidationTask(v) => {
14111 struct_ser.serialize_field("validationTask", v)?;
14112 }
14113 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
14114 struct_ser.serialize_field("cancelCompactTask", v)?;
14115 }
14116 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
14117 struct_ser.serialize_field("pullTaskAck", v)?;
14118 }
14119 }
14120 }
14121 struct_ser.end()
14122 }
14123}
14124impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
14125 #[allow(deprecated)]
14126 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14127 where
14128 D: serde::Deserializer<'de>,
14129 {
14130 const FIELDS: &[&str] = &[
14131 "create_at",
14132 "createAt",
14133 "compact_task",
14134 "compactTask",
14135 "vacuum_task",
14136 "vacuumTask",
14137 "full_scan_task",
14138 "fullScanTask",
14139 "validation_task",
14140 "validationTask",
14141 "cancel_compact_task",
14142 "cancelCompactTask",
14143 "pull_task_ack",
14144 "pullTaskAck",
14145 ];
14146
14147 #[allow(clippy::enum_variant_names)]
14148 enum GeneratedField {
14149 CreateAt,
14150 CompactTask,
14151 VacuumTask,
14152 FullScanTask,
14153 ValidationTask,
14154 CancelCompactTask,
14155 PullTaskAck,
14156 }
14157 impl<'de> serde::Deserialize<'de> for GeneratedField {
14158 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14159 where
14160 D: serde::Deserializer<'de>,
14161 {
14162 struct GeneratedVisitor;
14163
14164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14165 type Value = GeneratedField;
14166
14167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14168 write!(formatter, "expected one of: {:?}", &FIELDS)
14169 }
14170
14171 #[allow(unused_variables)]
14172 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14173 where
14174 E: serde::de::Error,
14175 {
14176 match value {
14177 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14178 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
14179 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
14180 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
14181 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
14182 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
14183 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
14184 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14185 }
14186 }
14187 }
14188 deserializer.deserialize_identifier(GeneratedVisitor)
14189 }
14190 }
14191 struct GeneratedVisitor;
14192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14193 type Value = SubscribeCompactionEventResponse;
14194
14195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14196 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
14197 }
14198
14199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
14200 where
14201 V: serde::de::MapAccess<'de>,
14202 {
14203 let mut create_at__ = None;
14204 let mut event__ = None;
14205 while let Some(k) = map_.next_key()? {
14206 match k {
14207 GeneratedField::CreateAt => {
14208 if create_at__.is_some() {
14209 return Err(serde::de::Error::duplicate_field("createAt"));
14210 }
14211 create_at__ =
14212 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14213 ;
14214 }
14215 GeneratedField::CompactTask => {
14216 if event__.is_some() {
14217 return Err(serde::de::Error::duplicate_field("compactTask"));
14218 }
14219 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
14220;
14221 }
14222 GeneratedField::VacuumTask => {
14223 if event__.is_some() {
14224 return Err(serde::de::Error::duplicate_field("vacuumTask"));
14225 }
14226 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
14227;
14228 }
14229 GeneratedField::FullScanTask => {
14230 if event__.is_some() {
14231 return Err(serde::de::Error::duplicate_field("fullScanTask"));
14232 }
14233 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
14234;
14235 }
14236 GeneratedField::ValidationTask => {
14237 if event__.is_some() {
14238 return Err(serde::de::Error::duplicate_field("validationTask"));
14239 }
14240 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
14241;
14242 }
14243 GeneratedField::CancelCompactTask => {
14244 if event__.is_some() {
14245 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
14246 }
14247 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
14248;
14249 }
14250 GeneratedField::PullTaskAck => {
14251 if event__.is_some() {
14252 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
14253 }
14254 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
14255;
14256 }
14257 }
14258 }
14259 Ok(SubscribeCompactionEventResponse {
14260 create_at: create_at__.unwrap_or_default(),
14261 event: event__,
14262 })
14263 }
14264 }
14265 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
14266 }
14267}
14268impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
14269 #[allow(deprecated)]
14270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14271 where
14272 S: serde::Serializer,
14273 {
14274 use serde::ser::SerializeStruct;
14275 let len = 0;
14276 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
14277 struct_ser.end()
14278 }
14279}
14280impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
14281 #[allow(deprecated)]
14282 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14283 where
14284 D: serde::Deserializer<'de>,
14285 {
14286 const FIELDS: &[&str] = &[
14287 ];
14288
14289 #[allow(clippy::enum_variant_names)]
14290 enum GeneratedField {
14291 }
14292 impl<'de> serde::Deserialize<'de> for GeneratedField {
14293 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14294 where
14295 D: serde::Deserializer<'de>,
14296 {
14297 struct GeneratedVisitor;
14298
14299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14300 type Value = GeneratedField;
14301
14302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14303 write!(formatter, "expected one of: {:?}", &FIELDS)
14304 }
14305
14306 #[allow(unused_variables)]
14307 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14308 where
14309 E: serde::de::Error,
14310 {
14311 Err(serde::de::Error::unknown_field(value, FIELDS))
14312 }
14313 }
14314 deserializer.deserialize_identifier(GeneratedVisitor)
14315 }
14316 }
14317 struct GeneratedVisitor;
14318 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14319 type Value = subscribe_compaction_event_response::PullTaskAck;
14320
14321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14322 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
14323 }
14324
14325 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
14326 where
14327 V: serde::de::MapAccess<'de>,
14328 {
14329 while map_.next_key::<GeneratedField>()?.is_some() {
14330 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14331 }
14332 Ok(subscribe_compaction_event_response::PullTaskAck {
14333 })
14334 }
14335 }
14336 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
14337 }
14338}
14339impl serde::Serialize for TableChangeLog {
14340 #[allow(deprecated)]
14341 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14342 where
14343 S: serde::Serializer,
14344 {
14345 use serde::ser::SerializeStruct;
14346 let mut len = 0;
14347 if !self.change_logs.is_empty() {
14348 len += 1;
14349 }
14350 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
14351 if !self.change_logs.is_empty() {
14352 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
14353 }
14354 struct_ser.end()
14355 }
14356}
14357impl<'de> serde::Deserialize<'de> for TableChangeLog {
14358 #[allow(deprecated)]
14359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14360 where
14361 D: serde::Deserializer<'de>,
14362 {
14363 const FIELDS: &[&str] = &[
14364 "change_logs",
14365 "changeLogs",
14366 ];
14367
14368 #[allow(clippy::enum_variant_names)]
14369 enum GeneratedField {
14370 ChangeLogs,
14371 }
14372 impl<'de> serde::Deserialize<'de> for GeneratedField {
14373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14374 where
14375 D: serde::Deserializer<'de>,
14376 {
14377 struct GeneratedVisitor;
14378
14379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14380 type Value = GeneratedField;
14381
14382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14383 write!(formatter, "expected one of: {:?}", &FIELDS)
14384 }
14385
14386 #[allow(unused_variables)]
14387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14388 where
14389 E: serde::de::Error,
14390 {
14391 match value {
14392 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
14393 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14394 }
14395 }
14396 }
14397 deserializer.deserialize_identifier(GeneratedVisitor)
14398 }
14399 }
14400 struct GeneratedVisitor;
14401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14402 type Value = TableChangeLog;
14403
14404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14405 formatter.write_str("struct hummock.TableChangeLog")
14406 }
14407
14408 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
14409 where
14410 V: serde::de::MapAccess<'de>,
14411 {
14412 let mut change_logs__ = None;
14413 while let Some(k) = map_.next_key()? {
14414 match k {
14415 GeneratedField::ChangeLogs => {
14416 if change_logs__.is_some() {
14417 return Err(serde::de::Error::duplicate_field("changeLogs"));
14418 }
14419 change_logs__ = Some(map_.next_value()?);
14420 }
14421 }
14422 }
14423 Ok(TableChangeLog {
14424 change_logs: change_logs__.unwrap_or_default(),
14425 })
14426 }
14427 }
14428 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
14429 }
14430}
14431impl serde::Serialize for TableOption {
14432 #[allow(deprecated)]
14433 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14434 where
14435 S: serde::Serializer,
14436 {
14437 use serde::ser::SerializeStruct;
14438 let mut len = 0;
14439 if self.retention_seconds.is_some() {
14440 len += 1;
14441 }
14442 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
14443 if let Some(v) = self.retention_seconds.as_ref() {
14444 struct_ser.serialize_field("retentionSeconds", v)?;
14445 }
14446 struct_ser.end()
14447 }
14448}
14449impl<'de> serde::Deserialize<'de> for TableOption {
14450 #[allow(deprecated)]
14451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14452 where
14453 D: serde::Deserializer<'de>,
14454 {
14455 const FIELDS: &[&str] = &[
14456 "retention_seconds",
14457 "retentionSeconds",
14458 ];
14459
14460 #[allow(clippy::enum_variant_names)]
14461 enum GeneratedField {
14462 RetentionSeconds,
14463 }
14464 impl<'de> serde::Deserialize<'de> for GeneratedField {
14465 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14466 where
14467 D: serde::Deserializer<'de>,
14468 {
14469 struct GeneratedVisitor;
14470
14471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14472 type Value = GeneratedField;
14473
14474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14475 write!(formatter, "expected one of: {:?}", &FIELDS)
14476 }
14477
14478 #[allow(unused_variables)]
14479 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14480 where
14481 E: serde::de::Error,
14482 {
14483 match value {
14484 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
14485 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14486 }
14487 }
14488 }
14489 deserializer.deserialize_identifier(GeneratedVisitor)
14490 }
14491 }
14492 struct GeneratedVisitor;
14493 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14494 type Value = TableOption;
14495
14496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14497 formatter.write_str("struct hummock.TableOption")
14498 }
14499
14500 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
14501 where
14502 V: serde::de::MapAccess<'de>,
14503 {
14504 let mut retention_seconds__ = None;
14505 while let Some(k) = map_.next_key()? {
14506 match k {
14507 GeneratedField::RetentionSeconds => {
14508 if retention_seconds__.is_some() {
14509 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
14510 }
14511 retention_seconds__ =
14512 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14513 ;
14514 }
14515 }
14516 }
14517 Ok(TableOption {
14518 retention_seconds: retention_seconds__,
14519 })
14520 }
14521 }
14522 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
14523 }
14524}
14525impl serde::Serialize for TableSchema {
14526 #[allow(deprecated)]
14527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14528 where
14529 S: serde::Serializer,
14530 {
14531 use serde::ser::SerializeStruct;
14532 let mut len = 0;
14533 if !self.column_ids.is_empty() {
14534 len += 1;
14535 }
14536 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
14537 if !self.column_ids.is_empty() {
14538 struct_ser.serialize_field("columnIds", &self.column_ids)?;
14539 }
14540 struct_ser.end()
14541 }
14542}
14543impl<'de> serde::Deserialize<'de> for TableSchema {
14544 #[allow(deprecated)]
14545 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14546 where
14547 D: serde::Deserializer<'de>,
14548 {
14549 const FIELDS: &[&str] = &[
14550 "column_ids",
14551 "columnIds",
14552 ];
14553
14554 #[allow(clippy::enum_variant_names)]
14555 enum GeneratedField {
14556 ColumnIds,
14557 }
14558 impl<'de> serde::Deserialize<'de> for GeneratedField {
14559 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14560 where
14561 D: serde::Deserializer<'de>,
14562 {
14563 struct GeneratedVisitor;
14564
14565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14566 type Value = GeneratedField;
14567
14568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14569 write!(formatter, "expected one of: {:?}", &FIELDS)
14570 }
14571
14572 #[allow(unused_variables)]
14573 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14574 where
14575 E: serde::de::Error,
14576 {
14577 match value {
14578 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
14579 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14580 }
14581 }
14582 }
14583 deserializer.deserialize_identifier(GeneratedVisitor)
14584 }
14585 }
14586 struct GeneratedVisitor;
14587 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14588 type Value = TableSchema;
14589
14590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14591 formatter.write_str("struct hummock.TableSchema")
14592 }
14593
14594 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
14595 where
14596 V: serde::de::MapAccess<'de>,
14597 {
14598 let mut column_ids__ = None;
14599 while let Some(k) = map_.next_key()? {
14600 match k {
14601 GeneratedField::ColumnIds => {
14602 if column_ids__.is_some() {
14603 return Err(serde::de::Error::duplicate_field("columnIds"));
14604 }
14605 column_ids__ =
14606 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14607 .into_iter().map(|x| x.0).collect())
14608 ;
14609 }
14610 }
14611 }
14612 Ok(TableSchema {
14613 column_ids: column_ids__.unwrap_or_default(),
14614 })
14615 }
14616 }
14617 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
14618 }
14619}
14620impl serde::Serialize for TableStats {
14621 #[allow(deprecated)]
14622 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14623 where
14624 S: serde::Serializer,
14625 {
14626 use serde::ser::SerializeStruct;
14627 let mut len = 0;
14628 if self.total_key_size != 0 {
14629 len += 1;
14630 }
14631 if self.total_value_size != 0 {
14632 len += 1;
14633 }
14634 if self.total_key_count != 0 {
14635 len += 1;
14636 }
14637 if self.total_compressed_size != 0 {
14638 len += 1;
14639 }
14640 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
14641 if self.total_key_size != 0 {
14642 #[allow(clippy::needless_borrow)]
14643 #[allow(clippy::needless_borrows_for_generic_args)]
14644 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
14645 }
14646 if self.total_value_size != 0 {
14647 #[allow(clippy::needless_borrow)]
14648 #[allow(clippy::needless_borrows_for_generic_args)]
14649 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
14650 }
14651 if self.total_key_count != 0 {
14652 #[allow(clippy::needless_borrow)]
14653 #[allow(clippy::needless_borrows_for_generic_args)]
14654 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
14655 }
14656 if self.total_compressed_size != 0 {
14657 #[allow(clippy::needless_borrow)]
14658 #[allow(clippy::needless_borrows_for_generic_args)]
14659 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
14660 }
14661 struct_ser.end()
14662 }
14663}
14664impl<'de> serde::Deserialize<'de> for TableStats {
14665 #[allow(deprecated)]
14666 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14667 where
14668 D: serde::Deserializer<'de>,
14669 {
14670 const FIELDS: &[&str] = &[
14671 "total_key_size",
14672 "totalKeySize",
14673 "total_value_size",
14674 "totalValueSize",
14675 "total_key_count",
14676 "totalKeyCount",
14677 "total_compressed_size",
14678 "totalCompressedSize",
14679 ];
14680
14681 #[allow(clippy::enum_variant_names)]
14682 enum GeneratedField {
14683 TotalKeySize,
14684 TotalValueSize,
14685 TotalKeyCount,
14686 TotalCompressedSize,
14687 }
14688 impl<'de> serde::Deserialize<'de> for GeneratedField {
14689 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14690 where
14691 D: serde::Deserializer<'de>,
14692 {
14693 struct GeneratedVisitor;
14694
14695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14696 type Value = GeneratedField;
14697
14698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14699 write!(formatter, "expected one of: {:?}", &FIELDS)
14700 }
14701
14702 #[allow(unused_variables)]
14703 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14704 where
14705 E: serde::de::Error,
14706 {
14707 match value {
14708 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
14709 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
14710 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
14711 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
14712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14713 }
14714 }
14715 }
14716 deserializer.deserialize_identifier(GeneratedVisitor)
14717 }
14718 }
14719 struct GeneratedVisitor;
14720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14721 type Value = TableStats;
14722
14723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14724 formatter.write_str("struct hummock.TableStats")
14725 }
14726
14727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
14728 where
14729 V: serde::de::MapAccess<'de>,
14730 {
14731 let mut total_key_size__ = None;
14732 let mut total_value_size__ = None;
14733 let mut total_key_count__ = None;
14734 let mut total_compressed_size__ = None;
14735 while let Some(k) = map_.next_key()? {
14736 match k {
14737 GeneratedField::TotalKeySize => {
14738 if total_key_size__.is_some() {
14739 return Err(serde::de::Error::duplicate_field("totalKeySize"));
14740 }
14741 total_key_size__ =
14742 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14743 ;
14744 }
14745 GeneratedField::TotalValueSize => {
14746 if total_value_size__.is_some() {
14747 return Err(serde::de::Error::duplicate_field("totalValueSize"));
14748 }
14749 total_value_size__ =
14750 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14751 ;
14752 }
14753 GeneratedField::TotalKeyCount => {
14754 if total_key_count__.is_some() {
14755 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
14756 }
14757 total_key_count__ =
14758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14759 ;
14760 }
14761 GeneratedField::TotalCompressedSize => {
14762 if total_compressed_size__.is_some() {
14763 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
14764 }
14765 total_compressed_size__ =
14766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14767 ;
14768 }
14769 }
14770 }
14771 Ok(TableStats {
14772 total_key_size: total_key_size__.unwrap_or_default(),
14773 total_value_size: total_value_size__.unwrap_or_default(),
14774 total_key_count: total_key_count__.unwrap_or_default(),
14775 total_compressed_size: total_compressed_size__.unwrap_or_default(),
14776 })
14777 }
14778 }
14779 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
14780 }
14781}
14782impl serde::Serialize for TableWatermarks {
14783 #[allow(deprecated)]
14784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14785 where
14786 S: serde::Serializer,
14787 {
14788 use serde::ser::SerializeStruct;
14789 let mut len = 0;
14790 if !self.epoch_watermarks.is_empty() {
14791 len += 1;
14792 }
14793 if self.is_ascending {
14794 len += 1;
14795 }
14796 if self.is_non_pk_prefix {
14797 len += 1;
14798 }
14799 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
14800 if !self.epoch_watermarks.is_empty() {
14801 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
14802 }
14803 if self.is_ascending {
14804 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
14805 }
14806 if self.is_non_pk_prefix {
14807 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
14808 }
14809 struct_ser.end()
14810 }
14811}
14812impl<'de> serde::Deserialize<'de> for TableWatermarks {
14813 #[allow(deprecated)]
14814 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14815 where
14816 D: serde::Deserializer<'de>,
14817 {
14818 const FIELDS: &[&str] = &[
14819 "epoch_watermarks",
14820 "epochWatermarks",
14821 "is_ascending",
14822 "isAscending",
14823 "is_non_pk_prefix",
14824 "isNonPkPrefix",
14825 ];
14826
14827 #[allow(clippy::enum_variant_names)]
14828 enum GeneratedField {
14829 EpochWatermarks,
14830 IsAscending,
14831 IsNonPkPrefix,
14832 }
14833 impl<'de> serde::Deserialize<'de> for GeneratedField {
14834 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14835 where
14836 D: serde::Deserializer<'de>,
14837 {
14838 struct GeneratedVisitor;
14839
14840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14841 type Value = GeneratedField;
14842
14843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14844 write!(formatter, "expected one of: {:?}", &FIELDS)
14845 }
14846
14847 #[allow(unused_variables)]
14848 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14849 where
14850 E: serde::de::Error,
14851 {
14852 match value {
14853 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
14854 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
14855 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
14856 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14857 }
14858 }
14859 }
14860 deserializer.deserialize_identifier(GeneratedVisitor)
14861 }
14862 }
14863 struct GeneratedVisitor;
14864 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14865 type Value = TableWatermarks;
14866
14867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14868 formatter.write_str("struct hummock.TableWatermarks")
14869 }
14870
14871 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
14872 where
14873 V: serde::de::MapAccess<'de>,
14874 {
14875 let mut epoch_watermarks__ = None;
14876 let mut is_ascending__ = None;
14877 let mut is_non_pk_prefix__ = None;
14878 while let Some(k) = map_.next_key()? {
14879 match k {
14880 GeneratedField::EpochWatermarks => {
14881 if epoch_watermarks__.is_some() {
14882 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
14883 }
14884 epoch_watermarks__ = Some(map_.next_value()?);
14885 }
14886 GeneratedField::IsAscending => {
14887 if is_ascending__.is_some() {
14888 return Err(serde::de::Error::duplicate_field("isAscending"));
14889 }
14890 is_ascending__ = Some(map_.next_value()?);
14891 }
14892 GeneratedField::IsNonPkPrefix => {
14893 if is_non_pk_prefix__.is_some() {
14894 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
14895 }
14896 is_non_pk_prefix__ = Some(map_.next_value()?);
14897 }
14898 }
14899 }
14900 Ok(TableWatermarks {
14901 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
14902 is_ascending: is_ascending__.unwrap_or_default(),
14903 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
14904 })
14905 }
14906 }
14907 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
14908 }
14909}
14910impl serde::Serialize for table_watermarks::EpochNewWatermarks {
14911 #[allow(deprecated)]
14912 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14913 where
14914 S: serde::Serializer,
14915 {
14916 use serde::ser::SerializeStruct;
14917 let mut len = 0;
14918 if !self.watermarks.is_empty() {
14919 len += 1;
14920 }
14921 if self.epoch != 0 {
14922 len += 1;
14923 }
14924 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
14925 if !self.watermarks.is_empty() {
14926 struct_ser.serialize_field("watermarks", &self.watermarks)?;
14927 }
14928 if self.epoch != 0 {
14929 #[allow(clippy::needless_borrow)]
14930 #[allow(clippy::needless_borrows_for_generic_args)]
14931 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
14932 }
14933 struct_ser.end()
14934 }
14935}
14936impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
14937 #[allow(deprecated)]
14938 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14939 where
14940 D: serde::Deserializer<'de>,
14941 {
14942 const FIELDS: &[&str] = &[
14943 "watermarks",
14944 "epoch",
14945 ];
14946
14947 #[allow(clippy::enum_variant_names)]
14948 enum GeneratedField {
14949 Watermarks,
14950 Epoch,
14951 }
14952 impl<'de> serde::Deserialize<'de> for GeneratedField {
14953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14954 where
14955 D: serde::Deserializer<'de>,
14956 {
14957 struct GeneratedVisitor;
14958
14959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14960 type Value = GeneratedField;
14961
14962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14963 write!(formatter, "expected one of: {:?}", &FIELDS)
14964 }
14965
14966 #[allow(unused_variables)]
14967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14968 where
14969 E: serde::de::Error,
14970 {
14971 match value {
14972 "watermarks" => Ok(GeneratedField::Watermarks),
14973 "epoch" => Ok(GeneratedField::Epoch),
14974 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14975 }
14976 }
14977 }
14978 deserializer.deserialize_identifier(GeneratedVisitor)
14979 }
14980 }
14981 struct GeneratedVisitor;
14982 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14983 type Value = table_watermarks::EpochNewWatermarks;
14984
14985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14986 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
14987 }
14988
14989 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
14990 where
14991 V: serde::de::MapAccess<'de>,
14992 {
14993 let mut watermarks__ = None;
14994 let mut epoch__ = None;
14995 while let Some(k) = map_.next_key()? {
14996 match k {
14997 GeneratedField::Watermarks => {
14998 if watermarks__.is_some() {
14999 return Err(serde::de::Error::duplicate_field("watermarks"));
15000 }
15001 watermarks__ = Some(map_.next_value()?);
15002 }
15003 GeneratedField::Epoch => {
15004 if epoch__.is_some() {
15005 return Err(serde::de::Error::duplicate_field("epoch"));
15006 }
15007 epoch__ =
15008 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15009 ;
15010 }
15011 }
15012 }
15013 Ok(table_watermarks::EpochNewWatermarks {
15014 watermarks: watermarks__.unwrap_or_default(),
15015 epoch: epoch__.unwrap_or_default(),
15016 })
15017 }
15018 }
15019 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
15020 }
15021}
15022impl serde::Serialize for TriggerCompactionDeterministicRequest {
15023 #[allow(deprecated)]
15024 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15025 where
15026 S: serde::Serializer,
15027 {
15028 use serde::ser::SerializeStruct;
15029 let mut len = 0;
15030 if self.version_id != 0 {
15031 len += 1;
15032 }
15033 if !self.compaction_groups.is_empty() {
15034 len += 1;
15035 }
15036 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
15037 if self.version_id != 0 {
15038 #[allow(clippy::needless_borrow)]
15039 #[allow(clippy::needless_borrows_for_generic_args)]
15040 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
15041 }
15042 if !self.compaction_groups.is_empty() {
15043 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15044 }
15045 struct_ser.end()
15046 }
15047}
15048impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
15049 #[allow(deprecated)]
15050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15051 where
15052 D: serde::Deserializer<'de>,
15053 {
15054 const FIELDS: &[&str] = &[
15055 "version_id",
15056 "versionId",
15057 "compaction_groups",
15058 "compactionGroups",
15059 ];
15060
15061 #[allow(clippy::enum_variant_names)]
15062 enum GeneratedField {
15063 VersionId,
15064 CompactionGroups,
15065 }
15066 impl<'de> serde::Deserialize<'de> for GeneratedField {
15067 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15068 where
15069 D: serde::Deserializer<'de>,
15070 {
15071 struct GeneratedVisitor;
15072
15073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15074 type Value = GeneratedField;
15075
15076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15077 write!(formatter, "expected one of: {:?}", &FIELDS)
15078 }
15079
15080 #[allow(unused_variables)]
15081 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15082 where
15083 E: serde::de::Error,
15084 {
15085 match value {
15086 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
15087 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
15088 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15089 }
15090 }
15091 }
15092 deserializer.deserialize_identifier(GeneratedVisitor)
15093 }
15094 }
15095 struct GeneratedVisitor;
15096 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15097 type Value = TriggerCompactionDeterministicRequest;
15098
15099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15100 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
15101 }
15102
15103 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
15104 where
15105 V: serde::de::MapAccess<'de>,
15106 {
15107 let mut version_id__ = None;
15108 let mut compaction_groups__ = None;
15109 while let Some(k) = map_.next_key()? {
15110 match k {
15111 GeneratedField::VersionId => {
15112 if version_id__.is_some() {
15113 return Err(serde::de::Error::duplicate_field("versionId"));
15114 }
15115 version_id__ =
15116 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15117 ;
15118 }
15119 GeneratedField::CompactionGroups => {
15120 if compaction_groups__.is_some() {
15121 return Err(serde::de::Error::duplicate_field("compactionGroups"));
15122 }
15123 compaction_groups__ =
15124 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15125 .into_iter().map(|x| x.0).collect())
15126 ;
15127 }
15128 }
15129 }
15130 Ok(TriggerCompactionDeterministicRequest {
15131 version_id: version_id__.unwrap_or_default(),
15132 compaction_groups: compaction_groups__.unwrap_or_default(),
15133 })
15134 }
15135 }
15136 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
15137 }
15138}
15139impl serde::Serialize for TriggerCompactionDeterministicResponse {
15140 #[allow(deprecated)]
15141 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15142 where
15143 S: serde::Serializer,
15144 {
15145 use serde::ser::SerializeStruct;
15146 let len = 0;
15147 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
15148 struct_ser.end()
15149 }
15150}
15151impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
15152 #[allow(deprecated)]
15153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15154 where
15155 D: serde::Deserializer<'de>,
15156 {
15157 const FIELDS: &[&str] = &[
15158 ];
15159
15160 #[allow(clippy::enum_variant_names)]
15161 enum GeneratedField {
15162 }
15163 impl<'de> serde::Deserialize<'de> for GeneratedField {
15164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15165 where
15166 D: serde::Deserializer<'de>,
15167 {
15168 struct GeneratedVisitor;
15169
15170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15171 type Value = GeneratedField;
15172
15173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15174 write!(formatter, "expected one of: {:?}", &FIELDS)
15175 }
15176
15177 #[allow(unused_variables)]
15178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15179 where
15180 E: serde::de::Error,
15181 {
15182 Err(serde::de::Error::unknown_field(value, FIELDS))
15183 }
15184 }
15185 deserializer.deserialize_identifier(GeneratedVisitor)
15186 }
15187 }
15188 struct GeneratedVisitor;
15189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15190 type Value = TriggerCompactionDeterministicResponse;
15191
15192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15193 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
15194 }
15195
15196 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
15197 where
15198 V: serde::de::MapAccess<'de>,
15199 {
15200 while map_.next_key::<GeneratedField>()?.is_some() {
15201 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15202 }
15203 Ok(TriggerCompactionDeterministicResponse {
15204 })
15205 }
15206 }
15207 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
15208 }
15209}
15210impl serde::Serialize for TriggerFullGcRequest {
15211 #[allow(deprecated)]
15212 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15213 where
15214 S: serde::Serializer,
15215 {
15216 use serde::ser::SerializeStruct;
15217 let mut len = 0;
15218 if self.sst_retention_time_sec != 0 {
15219 len += 1;
15220 }
15221 if self.prefix.is_some() {
15222 len += 1;
15223 }
15224 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
15225 if self.sst_retention_time_sec != 0 {
15226 #[allow(clippy::needless_borrow)]
15227 #[allow(clippy::needless_borrows_for_generic_args)]
15228 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
15229 }
15230 if let Some(v) = self.prefix.as_ref() {
15231 struct_ser.serialize_field("prefix", v)?;
15232 }
15233 struct_ser.end()
15234 }
15235}
15236impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
15237 #[allow(deprecated)]
15238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15239 where
15240 D: serde::Deserializer<'de>,
15241 {
15242 const FIELDS: &[&str] = &[
15243 "sst_retention_time_sec",
15244 "sstRetentionTimeSec",
15245 "prefix",
15246 ];
15247
15248 #[allow(clippy::enum_variant_names)]
15249 enum GeneratedField {
15250 SstRetentionTimeSec,
15251 Prefix,
15252 }
15253 impl<'de> serde::Deserialize<'de> for GeneratedField {
15254 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15255 where
15256 D: serde::Deserializer<'de>,
15257 {
15258 struct GeneratedVisitor;
15259
15260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15261 type Value = GeneratedField;
15262
15263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15264 write!(formatter, "expected one of: {:?}", &FIELDS)
15265 }
15266
15267 #[allow(unused_variables)]
15268 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15269 where
15270 E: serde::de::Error,
15271 {
15272 match value {
15273 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
15274 "prefix" => Ok(GeneratedField::Prefix),
15275 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15276 }
15277 }
15278 }
15279 deserializer.deserialize_identifier(GeneratedVisitor)
15280 }
15281 }
15282 struct GeneratedVisitor;
15283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15284 type Value = TriggerFullGcRequest;
15285
15286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15287 formatter.write_str("struct hummock.TriggerFullGCRequest")
15288 }
15289
15290 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
15291 where
15292 V: serde::de::MapAccess<'de>,
15293 {
15294 let mut sst_retention_time_sec__ = None;
15295 let mut prefix__ = None;
15296 while let Some(k) = map_.next_key()? {
15297 match k {
15298 GeneratedField::SstRetentionTimeSec => {
15299 if sst_retention_time_sec__.is_some() {
15300 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
15301 }
15302 sst_retention_time_sec__ =
15303 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15304 ;
15305 }
15306 GeneratedField::Prefix => {
15307 if prefix__.is_some() {
15308 return Err(serde::de::Error::duplicate_field("prefix"));
15309 }
15310 prefix__ = map_.next_value()?;
15311 }
15312 }
15313 }
15314 Ok(TriggerFullGcRequest {
15315 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
15316 prefix: prefix__,
15317 })
15318 }
15319 }
15320 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
15321 }
15322}
15323impl serde::Serialize for TriggerFullGcResponse {
15324 #[allow(deprecated)]
15325 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15326 where
15327 S: serde::Serializer,
15328 {
15329 use serde::ser::SerializeStruct;
15330 let mut len = 0;
15331 if self.status.is_some() {
15332 len += 1;
15333 }
15334 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
15335 if let Some(v) = self.status.as_ref() {
15336 struct_ser.serialize_field("status", v)?;
15337 }
15338 struct_ser.end()
15339 }
15340}
15341impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
15342 #[allow(deprecated)]
15343 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15344 where
15345 D: serde::Deserializer<'de>,
15346 {
15347 const FIELDS: &[&str] = &[
15348 "status",
15349 ];
15350
15351 #[allow(clippy::enum_variant_names)]
15352 enum GeneratedField {
15353 Status,
15354 }
15355 impl<'de> serde::Deserialize<'de> for GeneratedField {
15356 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15357 where
15358 D: serde::Deserializer<'de>,
15359 {
15360 struct GeneratedVisitor;
15361
15362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15363 type Value = GeneratedField;
15364
15365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15366 write!(formatter, "expected one of: {:?}", &FIELDS)
15367 }
15368
15369 #[allow(unused_variables)]
15370 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15371 where
15372 E: serde::de::Error,
15373 {
15374 match value {
15375 "status" => Ok(GeneratedField::Status),
15376 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15377 }
15378 }
15379 }
15380 deserializer.deserialize_identifier(GeneratedVisitor)
15381 }
15382 }
15383 struct GeneratedVisitor;
15384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15385 type Value = TriggerFullGcResponse;
15386
15387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15388 formatter.write_str("struct hummock.TriggerFullGCResponse")
15389 }
15390
15391 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
15392 where
15393 V: serde::de::MapAccess<'de>,
15394 {
15395 let mut status__ = None;
15396 while let Some(k) = map_.next_key()? {
15397 match k {
15398 GeneratedField::Status => {
15399 if status__.is_some() {
15400 return Err(serde::de::Error::duplicate_field("status"));
15401 }
15402 status__ = map_.next_value()?;
15403 }
15404 }
15405 }
15406 Ok(TriggerFullGcResponse {
15407 status: status__,
15408 })
15409 }
15410 }
15411 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
15412 }
15413}
15414impl serde::Serialize for TriggerManualCompactionRequest {
15415 #[allow(deprecated)]
15416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15417 where
15418 S: serde::Serializer,
15419 {
15420 use serde::ser::SerializeStruct;
15421 let mut len = 0;
15422 if self.compaction_group_id != 0 {
15423 len += 1;
15424 }
15425 if self.key_range.is_some() {
15426 len += 1;
15427 }
15428 if self.table_id != 0 {
15429 len += 1;
15430 }
15431 if self.level != 0 {
15432 len += 1;
15433 }
15434 if !self.sst_ids.is_empty() {
15435 len += 1;
15436 }
15437 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
15438 if self.compaction_group_id != 0 {
15439 #[allow(clippy::needless_borrow)]
15440 #[allow(clippy::needless_borrows_for_generic_args)]
15441 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
15442 }
15443 if let Some(v) = self.key_range.as_ref() {
15444 struct_ser.serialize_field("keyRange", v)?;
15445 }
15446 if self.table_id != 0 {
15447 struct_ser.serialize_field("tableId", &self.table_id)?;
15448 }
15449 if self.level != 0 {
15450 struct_ser.serialize_field("level", &self.level)?;
15451 }
15452 if !self.sst_ids.is_empty() {
15453 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15454 }
15455 struct_ser.end()
15456 }
15457}
15458impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
15459 #[allow(deprecated)]
15460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15461 where
15462 D: serde::Deserializer<'de>,
15463 {
15464 const FIELDS: &[&str] = &[
15465 "compaction_group_id",
15466 "compactionGroupId",
15467 "key_range",
15468 "keyRange",
15469 "table_id",
15470 "tableId",
15471 "level",
15472 "sst_ids",
15473 "sstIds",
15474 ];
15475
15476 #[allow(clippy::enum_variant_names)]
15477 enum GeneratedField {
15478 CompactionGroupId,
15479 KeyRange,
15480 TableId,
15481 Level,
15482 SstIds,
15483 }
15484 impl<'de> serde::Deserialize<'de> for GeneratedField {
15485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15486 where
15487 D: serde::Deserializer<'de>,
15488 {
15489 struct GeneratedVisitor;
15490
15491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15492 type Value = GeneratedField;
15493
15494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15495 write!(formatter, "expected one of: {:?}", &FIELDS)
15496 }
15497
15498 #[allow(unused_variables)]
15499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15500 where
15501 E: serde::de::Error,
15502 {
15503 match value {
15504 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
15505 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
15506 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15507 "level" => Ok(GeneratedField::Level),
15508 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
15509 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15510 }
15511 }
15512 }
15513 deserializer.deserialize_identifier(GeneratedVisitor)
15514 }
15515 }
15516 struct GeneratedVisitor;
15517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15518 type Value = TriggerManualCompactionRequest;
15519
15520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15521 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
15522 }
15523
15524 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
15525 where
15526 V: serde::de::MapAccess<'de>,
15527 {
15528 let mut compaction_group_id__ = None;
15529 let mut key_range__ = None;
15530 let mut table_id__ = None;
15531 let mut level__ = None;
15532 let mut sst_ids__ = None;
15533 while let Some(k) = map_.next_key()? {
15534 match k {
15535 GeneratedField::CompactionGroupId => {
15536 if compaction_group_id__.is_some() {
15537 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
15538 }
15539 compaction_group_id__ =
15540 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15541 ;
15542 }
15543 GeneratedField::KeyRange => {
15544 if key_range__.is_some() {
15545 return Err(serde::de::Error::duplicate_field("keyRange"));
15546 }
15547 key_range__ = map_.next_value()?;
15548 }
15549 GeneratedField::TableId => {
15550 if table_id__.is_some() {
15551 return Err(serde::de::Error::duplicate_field("tableId"));
15552 }
15553 table_id__ =
15554 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15555 ;
15556 }
15557 GeneratedField::Level => {
15558 if level__.is_some() {
15559 return Err(serde::de::Error::duplicate_field("level"));
15560 }
15561 level__ =
15562 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15563 ;
15564 }
15565 GeneratedField::SstIds => {
15566 if sst_ids__.is_some() {
15567 return Err(serde::de::Error::duplicate_field("sstIds"));
15568 }
15569 sst_ids__ =
15570 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15571 .into_iter().map(|x| x.0).collect())
15572 ;
15573 }
15574 }
15575 }
15576 Ok(TriggerManualCompactionRequest {
15577 compaction_group_id: compaction_group_id__.unwrap_or_default(),
15578 key_range: key_range__,
15579 table_id: table_id__.unwrap_or_default(),
15580 level: level__.unwrap_or_default(),
15581 sst_ids: sst_ids__.unwrap_or_default(),
15582 })
15583 }
15584 }
15585 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
15586 }
15587}
15588impl serde::Serialize for TriggerManualCompactionResponse {
15589 #[allow(deprecated)]
15590 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15591 where
15592 S: serde::Serializer,
15593 {
15594 use serde::ser::SerializeStruct;
15595 let mut len = 0;
15596 if self.status.is_some() {
15597 len += 1;
15598 }
15599 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
15600 if let Some(v) = self.status.as_ref() {
15601 struct_ser.serialize_field("status", v)?;
15602 }
15603 struct_ser.end()
15604 }
15605}
15606impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
15607 #[allow(deprecated)]
15608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15609 where
15610 D: serde::Deserializer<'de>,
15611 {
15612 const FIELDS: &[&str] = &[
15613 "status",
15614 ];
15615
15616 #[allow(clippy::enum_variant_names)]
15617 enum GeneratedField {
15618 Status,
15619 }
15620 impl<'de> serde::Deserialize<'de> for GeneratedField {
15621 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15622 where
15623 D: serde::Deserializer<'de>,
15624 {
15625 struct GeneratedVisitor;
15626
15627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15628 type Value = GeneratedField;
15629
15630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15631 write!(formatter, "expected one of: {:?}", &FIELDS)
15632 }
15633
15634 #[allow(unused_variables)]
15635 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15636 where
15637 E: serde::de::Error,
15638 {
15639 match value {
15640 "status" => Ok(GeneratedField::Status),
15641 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15642 }
15643 }
15644 }
15645 deserializer.deserialize_identifier(GeneratedVisitor)
15646 }
15647 }
15648 struct GeneratedVisitor;
15649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15650 type Value = TriggerManualCompactionResponse;
15651
15652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15653 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
15654 }
15655
15656 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
15657 where
15658 V: serde::de::MapAccess<'de>,
15659 {
15660 let mut status__ = None;
15661 while let Some(k) = map_.next_key()? {
15662 match k {
15663 GeneratedField::Status => {
15664 if status__.is_some() {
15665 return Err(serde::de::Error::duplicate_field("status"));
15666 }
15667 status__ = map_.next_value()?;
15668 }
15669 }
15670 }
15671 Ok(TriggerManualCompactionResponse {
15672 status: status__,
15673 })
15674 }
15675 }
15676 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
15677 }
15678}
15679impl serde::Serialize for UnpinVersionBeforeRequest {
15680 #[allow(deprecated)]
15681 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15682 where
15683 S: serde::Serializer,
15684 {
15685 use serde::ser::SerializeStruct;
15686 let mut len = 0;
15687 if self.context_id != 0 {
15688 len += 1;
15689 }
15690 if self.unpin_version_before != 0 {
15691 len += 1;
15692 }
15693 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
15694 if self.context_id != 0 {
15695 struct_ser.serialize_field("contextId", &self.context_id)?;
15696 }
15697 if self.unpin_version_before != 0 {
15698 #[allow(clippy::needless_borrow)]
15699 #[allow(clippy::needless_borrows_for_generic_args)]
15700 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
15701 }
15702 struct_ser.end()
15703 }
15704}
15705impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
15706 #[allow(deprecated)]
15707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15708 where
15709 D: serde::Deserializer<'de>,
15710 {
15711 const FIELDS: &[&str] = &[
15712 "context_id",
15713 "contextId",
15714 "unpin_version_before",
15715 "unpinVersionBefore",
15716 ];
15717
15718 #[allow(clippy::enum_variant_names)]
15719 enum GeneratedField {
15720 ContextId,
15721 UnpinVersionBefore,
15722 }
15723 impl<'de> serde::Deserialize<'de> for GeneratedField {
15724 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15725 where
15726 D: serde::Deserializer<'de>,
15727 {
15728 struct GeneratedVisitor;
15729
15730 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15731 type Value = GeneratedField;
15732
15733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15734 write!(formatter, "expected one of: {:?}", &FIELDS)
15735 }
15736
15737 #[allow(unused_variables)]
15738 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15739 where
15740 E: serde::de::Error,
15741 {
15742 match value {
15743 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15744 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
15745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15746 }
15747 }
15748 }
15749 deserializer.deserialize_identifier(GeneratedVisitor)
15750 }
15751 }
15752 struct GeneratedVisitor;
15753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15754 type Value = UnpinVersionBeforeRequest;
15755
15756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15757 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
15758 }
15759
15760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
15761 where
15762 V: serde::de::MapAccess<'de>,
15763 {
15764 let mut context_id__ = None;
15765 let mut unpin_version_before__ = None;
15766 while let Some(k) = map_.next_key()? {
15767 match k {
15768 GeneratedField::ContextId => {
15769 if context_id__.is_some() {
15770 return Err(serde::de::Error::duplicate_field("contextId"));
15771 }
15772 context_id__ =
15773 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15774 ;
15775 }
15776 GeneratedField::UnpinVersionBefore => {
15777 if unpin_version_before__.is_some() {
15778 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
15779 }
15780 unpin_version_before__ =
15781 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15782 ;
15783 }
15784 }
15785 }
15786 Ok(UnpinVersionBeforeRequest {
15787 context_id: context_id__.unwrap_or_default(),
15788 unpin_version_before: unpin_version_before__.unwrap_or_default(),
15789 })
15790 }
15791 }
15792 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
15793 }
15794}
15795impl serde::Serialize for UnpinVersionBeforeResponse {
15796 #[allow(deprecated)]
15797 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15798 where
15799 S: serde::Serializer,
15800 {
15801 use serde::ser::SerializeStruct;
15802 let mut len = 0;
15803 if self.status.is_some() {
15804 len += 1;
15805 }
15806 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
15807 if let Some(v) = self.status.as_ref() {
15808 struct_ser.serialize_field("status", v)?;
15809 }
15810 struct_ser.end()
15811 }
15812}
15813impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
15814 #[allow(deprecated)]
15815 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15816 where
15817 D: serde::Deserializer<'de>,
15818 {
15819 const FIELDS: &[&str] = &[
15820 "status",
15821 ];
15822
15823 #[allow(clippy::enum_variant_names)]
15824 enum GeneratedField {
15825 Status,
15826 }
15827 impl<'de> serde::Deserialize<'de> for GeneratedField {
15828 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15829 where
15830 D: serde::Deserializer<'de>,
15831 {
15832 struct GeneratedVisitor;
15833
15834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15835 type Value = GeneratedField;
15836
15837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15838 write!(formatter, "expected one of: {:?}", &FIELDS)
15839 }
15840
15841 #[allow(unused_variables)]
15842 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15843 where
15844 E: serde::de::Error,
15845 {
15846 match value {
15847 "status" => Ok(GeneratedField::Status),
15848 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15849 }
15850 }
15851 }
15852 deserializer.deserialize_identifier(GeneratedVisitor)
15853 }
15854 }
15855 struct GeneratedVisitor;
15856 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15857 type Value = UnpinVersionBeforeResponse;
15858
15859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15860 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
15861 }
15862
15863 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
15864 where
15865 V: serde::de::MapAccess<'de>,
15866 {
15867 let mut status__ = None;
15868 while let Some(k) = map_.next_key()? {
15869 match k {
15870 GeneratedField::Status => {
15871 if status__.is_some() {
15872 return Err(serde::de::Error::duplicate_field("status"));
15873 }
15874 status__ = map_.next_value()?;
15875 }
15876 }
15877 }
15878 Ok(UnpinVersionBeforeResponse {
15879 status: status__,
15880 })
15881 }
15882 }
15883 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
15884 }
15885}
15886impl serde::Serialize for UnpinVersionRequest {
15887 #[allow(deprecated)]
15888 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15889 where
15890 S: serde::Serializer,
15891 {
15892 use serde::ser::SerializeStruct;
15893 let mut len = 0;
15894 if self.context_id != 0 {
15895 len += 1;
15896 }
15897 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
15898 if self.context_id != 0 {
15899 struct_ser.serialize_field("contextId", &self.context_id)?;
15900 }
15901 struct_ser.end()
15902 }
15903}
15904impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
15905 #[allow(deprecated)]
15906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15907 where
15908 D: serde::Deserializer<'de>,
15909 {
15910 const FIELDS: &[&str] = &[
15911 "context_id",
15912 "contextId",
15913 ];
15914
15915 #[allow(clippy::enum_variant_names)]
15916 enum GeneratedField {
15917 ContextId,
15918 }
15919 impl<'de> serde::Deserialize<'de> for GeneratedField {
15920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15921 where
15922 D: serde::Deserializer<'de>,
15923 {
15924 struct GeneratedVisitor;
15925
15926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15927 type Value = GeneratedField;
15928
15929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15930 write!(formatter, "expected one of: {:?}", &FIELDS)
15931 }
15932
15933 #[allow(unused_variables)]
15934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15935 where
15936 E: serde::de::Error,
15937 {
15938 match value {
15939 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15940 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15941 }
15942 }
15943 }
15944 deserializer.deserialize_identifier(GeneratedVisitor)
15945 }
15946 }
15947 struct GeneratedVisitor;
15948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15949 type Value = UnpinVersionRequest;
15950
15951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15952 formatter.write_str("struct hummock.UnpinVersionRequest")
15953 }
15954
15955 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
15956 where
15957 V: serde::de::MapAccess<'de>,
15958 {
15959 let mut context_id__ = None;
15960 while let Some(k) = map_.next_key()? {
15961 match k {
15962 GeneratedField::ContextId => {
15963 if context_id__.is_some() {
15964 return Err(serde::de::Error::duplicate_field("contextId"));
15965 }
15966 context_id__ =
15967 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15968 ;
15969 }
15970 }
15971 }
15972 Ok(UnpinVersionRequest {
15973 context_id: context_id__.unwrap_or_default(),
15974 })
15975 }
15976 }
15977 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
15978 }
15979}
15980impl serde::Serialize for UnpinVersionResponse {
15981 #[allow(deprecated)]
15982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15983 where
15984 S: serde::Serializer,
15985 {
15986 use serde::ser::SerializeStruct;
15987 let mut len = 0;
15988 if self.status.is_some() {
15989 len += 1;
15990 }
15991 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
15992 if let Some(v) = self.status.as_ref() {
15993 struct_ser.serialize_field("status", v)?;
15994 }
15995 struct_ser.end()
15996 }
15997}
15998impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
15999 #[allow(deprecated)]
16000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16001 where
16002 D: serde::Deserializer<'de>,
16003 {
16004 const FIELDS: &[&str] = &[
16005 "status",
16006 ];
16007
16008 #[allow(clippy::enum_variant_names)]
16009 enum GeneratedField {
16010 Status,
16011 }
16012 impl<'de> serde::Deserialize<'de> for GeneratedField {
16013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16014 where
16015 D: serde::Deserializer<'de>,
16016 {
16017 struct GeneratedVisitor;
16018
16019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16020 type Value = GeneratedField;
16021
16022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16023 write!(formatter, "expected one of: {:?}", &FIELDS)
16024 }
16025
16026 #[allow(unused_variables)]
16027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16028 where
16029 E: serde::de::Error,
16030 {
16031 match value {
16032 "status" => Ok(GeneratedField::Status),
16033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16034 }
16035 }
16036 }
16037 deserializer.deserialize_identifier(GeneratedVisitor)
16038 }
16039 }
16040 struct GeneratedVisitor;
16041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16042 type Value = UnpinVersionResponse;
16043
16044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16045 formatter.write_str("struct hummock.UnpinVersionResponse")
16046 }
16047
16048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
16049 where
16050 V: serde::de::MapAccess<'de>,
16051 {
16052 let mut status__ = None;
16053 while let Some(k) = map_.next_key()? {
16054 match k {
16055 GeneratedField::Status => {
16056 if status__.is_some() {
16057 return Err(serde::de::Error::duplicate_field("status"));
16058 }
16059 status__ = map_.next_value()?;
16060 }
16061 }
16062 }
16063 Ok(UnpinVersionResponse {
16064 status: status__,
16065 })
16066 }
16067 }
16068 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
16069 }
16070}
16071impl serde::Serialize for VacuumTask {
16072 #[allow(deprecated)]
16073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16074 where
16075 S: serde::Serializer,
16076 {
16077 use serde::ser::SerializeStruct;
16078 let mut len = 0;
16079 if !self.sstable_object_ids.is_empty() {
16080 len += 1;
16081 }
16082 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
16083 if !self.sstable_object_ids.is_empty() {
16084 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16085 }
16086 struct_ser.end()
16087 }
16088}
16089impl<'de> serde::Deserialize<'de> for VacuumTask {
16090 #[allow(deprecated)]
16091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16092 where
16093 D: serde::Deserializer<'de>,
16094 {
16095 const FIELDS: &[&str] = &[
16096 "sstable_object_ids",
16097 "sstableObjectIds",
16098 ];
16099
16100 #[allow(clippy::enum_variant_names)]
16101 enum GeneratedField {
16102 SstableObjectIds,
16103 }
16104 impl<'de> serde::Deserialize<'de> for GeneratedField {
16105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16106 where
16107 D: serde::Deserializer<'de>,
16108 {
16109 struct GeneratedVisitor;
16110
16111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16112 type Value = GeneratedField;
16113
16114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16115 write!(formatter, "expected one of: {:?}", &FIELDS)
16116 }
16117
16118 #[allow(unused_variables)]
16119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16120 where
16121 E: serde::de::Error,
16122 {
16123 match value {
16124 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
16125 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16126 }
16127 }
16128 }
16129 deserializer.deserialize_identifier(GeneratedVisitor)
16130 }
16131 }
16132 struct GeneratedVisitor;
16133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16134 type Value = VacuumTask;
16135
16136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16137 formatter.write_str("struct hummock.VacuumTask")
16138 }
16139
16140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
16141 where
16142 V: serde::de::MapAccess<'de>,
16143 {
16144 let mut sstable_object_ids__ = None;
16145 while let Some(k) = map_.next_key()? {
16146 match k {
16147 GeneratedField::SstableObjectIds => {
16148 if sstable_object_ids__.is_some() {
16149 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
16150 }
16151 sstable_object_ids__ =
16152 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16153 .into_iter().map(|x| x.0).collect())
16154 ;
16155 }
16156 }
16157 }
16158 Ok(VacuumTask {
16159 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
16160 })
16161 }
16162 }
16163 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
16164 }
16165}
16166impl serde::Serialize for ValidationTask {
16167 #[allow(deprecated)]
16168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16169 where
16170 S: serde::Serializer,
16171 {
16172 use serde::ser::SerializeStruct;
16173 let mut len = 0;
16174 if !self.sst_infos.is_empty() {
16175 len += 1;
16176 }
16177 if !self.sst_id_to_worker_id.is_empty() {
16178 len += 1;
16179 }
16180 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
16181 if !self.sst_infos.is_empty() {
16182 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
16183 }
16184 if !self.sst_id_to_worker_id.is_empty() {
16185 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
16186 }
16187 struct_ser.end()
16188 }
16189}
16190impl<'de> serde::Deserialize<'de> for ValidationTask {
16191 #[allow(deprecated)]
16192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16193 where
16194 D: serde::Deserializer<'de>,
16195 {
16196 const FIELDS: &[&str] = &[
16197 "sst_infos",
16198 "sstInfos",
16199 "sst_id_to_worker_id",
16200 "sstIdToWorkerId",
16201 ];
16202
16203 #[allow(clippy::enum_variant_names)]
16204 enum GeneratedField {
16205 SstInfos,
16206 SstIdToWorkerId,
16207 }
16208 impl<'de> serde::Deserialize<'de> for GeneratedField {
16209 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16210 where
16211 D: serde::Deserializer<'de>,
16212 {
16213 struct GeneratedVisitor;
16214
16215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16216 type Value = GeneratedField;
16217
16218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16219 write!(formatter, "expected one of: {:?}", &FIELDS)
16220 }
16221
16222 #[allow(unused_variables)]
16223 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16224 where
16225 E: serde::de::Error,
16226 {
16227 match value {
16228 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
16229 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
16230 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16231 }
16232 }
16233 }
16234 deserializer.deserialize_identifier(GeneratedVisitor)
16235 }
16236 }
16237 struct GeneratedVisitor;
16238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16239 type Value = ValidationTask;
16240
16241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16242 formatter.write_str("struct hummock.ValidationTask")
16243 }
16244
16245 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
16246 where
16247 V: serde::de::MapAccess<'de>,
16248 {
16249 let mut sst_infos__ = None;
16250 let mut sst_id_to_worker_id__ = None;
16251 while let Some(k) = map_.next_key()? {
16252 match k {
16253 GeneratedField::SstInfos => {
16254 if sst_infos__.is_some() {
16255 return Err(serde::de::Error::duplicate_field("sstInfos"));
16256 }
16257 sst_infos__ = Some(map_.next_value()?);
16258 }
16259 GeneratedField::SstIdToWorkerId => {
16260 if sst_id_to_worker_id__.is_some() {
16261 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
16262 }
16263 sst_id_to_worker_id__ = Some(
16264 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
16265 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
16266 );
16267 }
16268 }
16269 }
16270 Ok(ValidationTask {
16271 sst_infos: sst_infos__.unwrap_or_default(),
16272 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
16273 })
16274 }
16275 }
16276 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
16277 }
16278}
16279impl serde::Serialize for VectorFileInfo {
16280 #[allow(deprecated)]
16281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16282 where
16283 S: serde::Serializer,
16284 {
16285 use serde::ser::SerializeStruct;
16286 let mut len = 0;
16287 if self.object_id != 0 {
16288 len += 1;
16289 }
16290 if self.file_size != 0 {
16291 len += 1;
16292 }
16293 if self.start_vector_id != 0 {
16294 len += 1;
16295 }
16296 if self.vector_count != 0 {
16297 len += 1;
16298 }
16299 if self.meta_offset != 0 {
16300 len += 1;
16301 }
16302 let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
16303 if self.object_id != 0 {
16304 #[allow(clippy::needless_borrow)]
16305 #[allow(clippy::needless_borrows_for_generic_args)]
16306 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
16307 }
16308 if self.file_size != 0 {
16309 #[allow(clippy::needless_borrow)]
16310 #[allow(clippy::needless_borrows_for_generic_args)]
16311 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
16312 }
16313 if self.start_vector_id != 0 {
16314 #[allow(clippy::needless_borrow)]
16315 #[allow(clippy::needless_borrows_for_generic_args)]
16316 struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
16317 }
16318 if self.vector_count != 0 {
16319 struct_ser.serialize_field("vectorCount", &self.vector_count)?;
16320 }
16321 if self.meta_offset != 0 {
16322 #[allow(clippy::needless_borrow)]
16323 #[allow(clippy::needless_borrows_for_generic_args)]
16324 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
16325 }
16326 struct_ser.end()
16327 }
16328}
16329impl<'de> serde::Deserialize<'de> for VectorFileInfo {
16330 #[allow(deprecated)]
16331 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16332 where
16333 D: serde::Deserializer<'de>,
16334 {
16335 const FIELDS: &[&str] = &[
16336 "object_id",
16337 "objectId",
16338 "file_size",
16339 "fileSize",
16340 "start_vector_id",
16341 "startVectorId",
16342 "vector_count",
16343 "vectorCount",
16344 "meta_offset",
16345 "metaOffset",
16346 ];
16347
16348 #[allow(clippy::enum_variant_names)]
16349 enum GeneratedField {
16350 ObjectId,
16351 FileSize,
16352 StartVectorId,
16353 VectorCount,
16354 MetaOffset,
16355 }
16356 impl<'de> serde::Deserialize<'de> for GeneratedField {
16357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16358 where
16359 D: serde::Deserializer<'de>,
16360 {
16361 struct GeneratedVisitor;
16362
16363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16364 type Value = GeneratedField;
16365
16366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16367 write!(formatter, "expected one of: {:?}", &FIELDS)
16368 }
16369
16370 #[allow(unused_variables)]
16371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16372 where
16373 E: serde::de::Error,
16374 {
16375 match value {
16376 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
16377 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
16378 "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
16379 "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
16380 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
16381 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16382 }
16383 }
16384 }
16385 deserializer.deserialize_identifier(GeneratedVisitor)
16386 }
16387 }
16388 struct GeneratedVisitor;
16389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16390 type Value = VectorFileInfo;
16391
16392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16393 formatter.write_str("struct hummock.VectorFileInfo")
16394 }
16395
16396 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
16397 where
16398 V: serde::de::MapAccess<'de>,
16399 {
16400 let mut object_id__ = None;
16401 let mut file_size__ = None;
16402 let mut start_vector_id__ = None;
16403 let mut vector_count__ = None;
16404 let mut meta_offset__ = None;
16405 while let Some(k) = map_.next_key()? {
16406 match k {
16407 GeneratedField::ObjectId => {
16408 if object_id__.is_some() {
16409 return Err(serde::de::Error::duplicate_field("objectId"));
16410 }
16411 object_id__ =
16412 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16413 ;
16414 }
16415 GeneratedField::FileSize => {
16416 if file_size__.is_some() {
16417 return Err(serde::de::Error::duplicate_field("fileSize"));
16418 }
16419 file_size__ =
16420 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16421 ;
16422 }
16423 GeneratedField::StartVectorId => {
16424 if start_vector_id__.is_some() {
16425 return Err(serde::de::Error::duplicate_field("startVectorId"));
16426 }
16427 start_vector_id__ =
16428 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16429 ;
16430 }
16431 GeneratedField::VectorCount => {
16432 if vector_count__.is_some() {
16433 return Err(serde::de::Error::duplicate_field("vectorCount"));
16434 }
16435 vector_count__ =
16436 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16437 ;
16438 }
16439 GeneratedField::MetaOffset => {
16440 if meta_offset__.is_some() {
16441 return Err(serde::de::Error::duplicate_field("metaOffset"));
16442 }
16443 meta_offset__ =
16444 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16445 ;
16446 }
16447 }
16448 }
16449 Ok(VectorFileInfo {
16450 object_id: object_id__.unwrap_or_default(),
16451 file_size: file_size__.unwrap_or_default(),
16452 start_vector_id: start_vector_id__.unwrap_or_default(),
16453 vector_count: vector_count__.unwrap_or_default(),
16454 meta_offset: meta_offset__.unwrap_or_default(),
16455 })
16456 }
16457 }
16458 deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
16459 }
16460}
16461impl serde::Serialize for VectorIndex {
16462 #[allow(deprecated)]
16463 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16464 where
16465 S: serde::Serializer,
16466 {
16467 use serde::ser::SerializeStruct;
16468 let mut len = 0;
16469 if self.dimension != 0 {
16470 len += 1;
16471 }
16472 if self.distance_type != 0 {
16473 len += 1;
16474 }
16475 if self.variant.is_some() {
16476 len += 1;
16477 }
16478 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
16479 if self.dimension != 0 {
16480 struct_ser.serialize_field("dimension", &self.dimension)?;
16481 }
16482 if self.distance_type != 0 {
16483 let v = DistanceType::try_from(self.distance_type)
16484 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
16485 struct_ser.serialize_field("distanceType", &v)?;
16486 }
16487 if let Some(v) = self.variant.as_ref() {
16488 match v {
16489 vector_index::Variant::Flat(v) => {
16490 struct_ser.serialize_field("flat", v)?;
16491 }
16492 }
16493 }
16494 struct_ser.end()
16495 }
16496}
16497impl<'de> serde::Deserialize<'de> for VectorIndex {
16498 #[allow(deprecated)]
16499 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16500 where
16501 D: serde::Deserializer<'de>,
16502 {
16503 const FIELDS: &[&str] = &[
16504 "dimension",
16505 "distance_type",
16506 "distanceType",
16507 "flat",
16508 ];
16509
16510 #[allow(clippy::enum_variant_names)]
16511 enum GeneratedField {
16512 Dimension,
16513 DistanceType,
16514 Flat,
16515 }
16516 impl<'de> serde::Deserialize<'de> for GeneratedField {
16517 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16518 where
16519 D: serde::Deserializer<'de>,
16520 {
16521 struct GeneratedVisitor;
16522
16523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16524 type Value = GeneratedField;
16525
16526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16527 write!(formatter, "expected one of: {:?}", &FIELDS)
16528 }
16529
16530 #[allow(unused_variables)]
16531 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16532 where
16533 E: serde::de::Error,
16534 {
16535 match value {
16536 "dimension" => Ok(GeneratedField::Dimension),
16537 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
16538 "flat" => Ok(GeneratedField::Flat),
16539 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16540 }
16541 }
16542 }
16543 deserializer.deserialize_identifier(GeneratedVisitor)
16544 }
16545 }
16546 struct GeneratedVisitor;
16547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16548 type Value = VectorIndex;
16549
16550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16551 formatter.write_str("struct hummock.VectorIndex")
16552 }
16553
16554 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
16555 where
16556 V: serde::de::MapAccess<'de>,
16557 {
16558 let mut dimension__ = None;
16559 let mut distance_type__ = None;
16560 let mut variant__ = None;
16561 while let Some(k) = map_.next_key()? {
16562 match k {
16563 GeneratedField::Dimension => {
16564 if dimension__.is_some() {
16565 return Err(serde::de::Error::duplicate_field("dimension"));
16566 }
16567 dimension__ =
16568 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16569 ;
16570 }
16571 GeneratedField::DistanceType => {
16572 if distance_type__.is_some() {
16573 return Err(serde::de::Error::duplicate_field("distanceType"));
16574 }
16575 distance_type__ = Some(map_.next_value::<DistanceType>()? as i32);
16576 }
16577 GeneratedField::Flat => {
16578 if variant__.is_some() {
16579 return Err(serde::de::Error::duplicate_field("flat"));
16580 }
16581 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
16582;
16583 }
16584 }
16585 }
16586 Ok(VectorIndex {
16587 dimension: dimension__.unwrap_or_default(),
16588 distance_type: distance_type__.unwrap_or_default(),
16589 variant: variant__,
16590 })
16591 }
16592 }
16593 deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
16594 }
16595}
16596impl serde::Serialize for VectorIndexDelta {
16597 #[allow(deprecated)]
16598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16599 where
16600 S: serde::Serializer,
16601 {
16602 use serde::ser::SerializeStruct;
16603 let mut len = 0;
16604 if self.delta.is_some() {
16605 len += 1;
16606 }
16607 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
16608 if let Some(v) = self.delta.as_ref() {
16609 match v {
16610 vector_index_delta::Delta::Init(v) => {
16611 struct_ser.serialize_field("init", v)?;
16612 }
16613 vector_index_delta::Delta::Adds(v) => {
16614 struct_ser.serialize_field("adds", v)?;
16615 }
16616 }
16617 }
16618 struct_ser.end()
16619 }
16620}
16621impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
16622 #[allow(deprecated)]
16623 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16624 where
16625 D: serde::Deserializer<'de>,
16626 {
16627 const FIELDS: &[&str] = &[
16628 "init",
16629 "adds",
16630 ];
16631
16632 #[allow(clippy::enum_variant_names)]
16633 enum GeneratedField {
16634 Init,
16635 Adds,
16636 }
16637 impl<'de> serde::Deserialize<'de> for GeneratedField {
16638 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16639 where
16640 D: serde::Deserializer<'de>,
16641 {
16642 struct GeneratedVisitor;
16643
16644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16645 type Value = GeneratedField;
16646
16647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16648 write!(formatter, "expected one of: {:?}", &FIELDS)
16649 }
16650
16651 #[allow(unused_variables)]
16652 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16653 where
16654 E: serde::de::Error,
16655 {
16656 match value {
16657 "init" => Ok(GeneratedField::Init),
16658 "adds" => Ok(GeneratedField::Adds),
16659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16660 }
16661 }
16662 }
16663 deserializer.deserialize_identifier(GeneratedVisitor)
16664 }
16665 }
16666 struct GeneratedVisitor;
16667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16668 type Value = VectorIndexDelta;
16669
16670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16671 formatter.write_str("struct hummock.VectorIndexDelta")
16672 }
16673
16674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
16675 where
16676 V: serde::de::MapAccess<'de>,
16677 {
16678 let mut delta__ = None;
16679 while let Some(k) = map_.next_key()? {
16680 match k {
16681 GeneratedField::Init => {
16682 if delta__.is_some() {
16683 return Err(serde::de::Error::duplicate_field("init"));
16684 }
16685 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
16686;
16687 }
16688 GeneratedField::Adds => {
16689 if delta__.is_some() {
16690 return Err(serde::de::Error::duplicate_field("adds"));
16691 }
16692 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
16693;
16694 }
16695 }
16696 }
16697 Ok(VectorIndexDelta {
16698 delta: delta__,
16699 })
16700 }
16701 }
16702 deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
16703 }
16704}
16705impl serde::Serialize for vector_index_delta::VectorIndexAdd {
16706 #[allow(deprecated)]
16707 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16708 where
16709 S: serde::Serializer,
16710 {
16711 use serde::ser::SerializeStruct;
16712 let mut len = 0;
16713 if self.add.is_some() {
16714 len += 1;
16715 }
16716 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
16717 if let Some(v) = self.add.as_ref() {
16718 match v {
16719 vector_index_delta::vector_index_add::Add::Flat(v) => {
16720 struct_ser.serialize_field("flat", v)?;
16721 }
16722 }
16723 }
16724 struct_ser.end()
16725 }
16726}
16727impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
16728 #[allow(deprecated)]
16729 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16730 where
16731 D: serde::Deserializer<'de>,
16732 {
16733 const FIELDS: &[&str] = &[
16734 "flat",
16735 ];
16736
16737 #[allow(clippy::enum_variant_names)]
16738 enum GeneratedField {
16739 Flat,
16740 }
16741 impl<'de> serde::Deserialize<'de> for GeneratedField {
16742 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16743 where
16744 D: serde::Deserializer<'de>,
16745 {
16746 struct GeneratedVisitor;
16747
16748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16749 type Value = GeneratedField;
16750
16751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16752 write!(formatter, "expected one of: {:?}", &FIELDS)
16753 }
16754
16755 #[allow(unused_variables)]
16756 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16757 where
16758 E: serde::de::Error,
16759 {
16760 match value {
16761 "flat" => Ok(GeneratedField::Flat),
16762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16763 }
16764 }
16765 }
16766 deserializer.deserialize_identifier(GeneratedVisitor)
16767 }
16768 }
16769 struct GeneratedVisitor;
16770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16771 type Value = vector_index_delta::VectorIndexAdd;
16772
16773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16774 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
16775 }
16776
16777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
16778 where
16779 V: serde::de::MapAccess<'de>,
16780 {
16781 let mut add__ = None;
16782 while let Some(k) = map_.next_key()? {
16783 match k {
16784 GeneratedField::Flat => {
16785 if add__.is_some() {
16786 return Err(serde::de::Error::duplicate_field("flat"));
16787 }
16788 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
16789;
16790 }
16791 }
16792 }
16793 Ok(vector_index_delta::VectorIndexAdd {
16794 add: add__,
16795 })
16796 }
16797 }
16798 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
16799 }
16800}
16801impl serde::Serialize for vector_index_delta::VectorIndexAdds {
16802 #[allow(deprecated)]
16803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16804 where
16805 S: serde::Serializer,
16806 {
16807 use serde::ser::SerializeStruct;
16808 let mut len = 0;
16809 if !self.adds.is_empty() {
16810 len += 1;
16811 }
16812 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
16813 if !self.adds.is_empty() {
16814 struct_ser.serialize_field("adds", &self.adds)?;
16815 }
16816 struct_ser.end()
16817 }
16818}
16819impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
16820 #[allow(deprecated)]
16821 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16822 where
16823 D: serde::Deserializer<'de>,
16824 {
16825 const FIELDS: &[&str] = &[
16826 "adds",
16827 ];
16828
16829 #[allow(clippy::enum_variant_names)]
16830 enum GeneratedField {
16831 Adds,
16832 }
16833 impl<'de> serde::Deserialize<'de> for GeneratedField {
16834 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16835 where
16836 D: serde::Deserializer<'de>,
16837 {
16838 struct GeneratedVisitor;
16839
16840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16841 type Value = GeneratedField;
16842
16843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16844 write!(formatter, "expected one of: {:?}", &FIELDS)
16845 }
16846
16847 #[allow(unused_variables)]
16848 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16849 where
16850 E: serde::de::Error,
16851 {
16852 match value {
16853 "adds" => Ok(GeneratedField::Adds),
16854 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16855 }
16856 }
16857 }
16858 deserializer.deserialize_identifier(GeneratedVisitor)
16859 }
16860 }
16861 struct GeneratedVisitor;
16862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16863 type Value = vector_index_delta::VectorIndexAdds;
16864
16865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16866 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
16867 }
16868
16869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
16870 where
16871 V: serde::de::MapAccess<'de>,
16872 {
16873 let mut adds__ = None;
16874 while let Some(k) = map_.next_key()? {
16875 match k {
16876 GeneratedField::Adds => {
16877 if adds__.is_some() {
16878 return Err(serde::de::Error::duplicate_field("adds"));
16879 }
16880 adds__ = Some(map_.next_value()?);
16881 }
16882 }
16883 }
16884 Ok(vector_index_delta::VectorIndexAdds {
16885 adds: adds__.unwrap_or_default(),
16886 })
16887 }
16888 }
16889 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
16890 }
16891}
16892impl serde::Serialize for vector_index_delta::VectorIndexInit {
16893 #[allow(deprecated)]
16894 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16895 where
16896 S: serde::Serializer,
16897 {
16898 use serde::ser::SerializeStruct;
16899 let mut len = 0;
16900 if self.dimension != 0 {
16901 len += 1;
16902 }
16903 if self.distance_type != 0 {
16904 len += 1;
16905 }
16906 if self.config.is_some() {
16907 len += 1;
16908 }
16909 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
16910 if self.dimension != 0 {
16911 struct_ser.serialize_field("dimension", &self.dimension)?;
16912 }
16913 if self.distance_type != 0 {
16914 let v = DistanceType::try_from(self.distance_type)
16915 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
16916 struct_ser.serialize_field("distanceType", &v)?;
16917 }
16918 if let Some(v) = self.config.as_ref() {
16919 match v {
16920 vector_index_delta::vector_index_init::Config::Flat(v) => {
16921 struct_ser.serialize_field("flat", v)?;
16922 }
16923 }
16924 }
16925 struct_ser.end()
16926 }
16927}
16928impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
16929 #[allow(deprecated)]
16930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16931 where
16932 D: serde::Deserializer<'de>,
16933 {
16934 const FIELDS: &[&str] = &[
16935 "dimension",
16936 "distance_type",
16937 "distanceType",
16938 "flat",
16939 ];
16940
16941 #[allow(clippy::enum_variant_names)]
16942 enum GeneratedField {
16943 Dimension,
16944 DistanceType,
16945 Flat,
16946 }
16947 impl<'de> serde::Deserialize<'de> for GeneratedField {
16948 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16949 where
16950 D: serde::Deserializer<'de>,
16951 {
16952 struct GeneratedVisitor;
16953
16954 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16955 type Value = GeneratedField;
16956
16957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16958 write!(formatter, "expected one of: {:?}", &FIELDS)
16959 }
16960
16961 #[allow(unused_variables)]
16962 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16963 where
16964 E: serde::de::Error,
16965 {
16966 match value {
16967 "dimension" => Ok(GeneratedField::Dimension),
16968 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
16969 "flat" => Ok(GeneratedField::Flat),
16970 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16971 }
16972 }
16973 }
16974 deserializer.deserialize_identifier(GeneratedVisitor)
16975 }
16976 }
16977 struct GeneratedVisitor;
16978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16979 type Value = vector_index_delta::VectorIndexInit;
16980
16981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16982 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
16983 }
16984
16985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
16986 where
16987 V: serde::de::MapAccess<'de>,
16988 {
16989 let mut dimension__ = None;
16990 let mut distance_type__ = None;
16991 let mut config__ = None;
16992 while let Some(k) = map_.next_key()? {
16993 match k {
16994 GeneratedField::Dimension => {
16995 if dimension__.is_some() {
16996 return Err(serde::de::Error::duplicate_field("dimension"));
16997 }
16998 dimension__ =
16999 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17000 ;
17001 }
17002 GeneratedField::DistanceType => {
17003 if distance_type__.is_some() {
17004 return Err(serde::de::Error::duplicate_field("distanceType"));
17005 }
17006 distance_type__ = Some(map_.next_value::<DistanceType>()? as i32);
17007 }
17008 GeneratedField::Flat => {
17009 if config__.is_some() {
17010 return Err(serde::de::Error::duplicate_field("flat"));
17011 }
17012 config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_init::Config::Flat)
17013;
17014 }
17015 }
17016 }
17017 Ok(vector_index_delta::VectorIndexInit {
17018 dimension: dimension__.unwrap_or_default(),
17019 distance_type: distance_type__.unwrap_or_default(),
17020 config: config__,
17021 })
17022 }
17023 }
17024 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
17025 }
17026}
17027impl serde::Serialize for VectorIndexObject {
17028 #[allow(deprecated)]
17029 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17030 where
17031 S: serde::Serializer,
17032 {
17033 use serde::ser::SerializeStruct;
17034 let mut len = 0;
17035 if self.id != 0 {
17036 len += 1;
17037 }
17038 if self.object_type != 0 {
17039 len += 1;
17040 }
17041 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
17042 if self.id != 0 {
17043 #[allow(clippy::needless_borrow)]
17044 #[allow(clippy::needless_borrows_for_generic_args)]
17045 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
17046 }
17047 if self.object_type != 0 {
17048 let v = VectorIndexObjectType::try_from(self.object_type)
17049 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
17050 struct_ser.serialize_field("objectType", &v)?;
17051 }
17052 struct_ser.end()
17053 }
17054}
17055impl<'de> serde::Deserialize<'de> for VectorIndexObject {
17056 #[allow(deprecated)]
17057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17058 where
17059 D: serde::Deserializer<'de>,
17060 {
17061 const FIELDS: &[&str] = &[
17062 "id",
17063 "object_type",
17064 "objectType",
17065 ];
17066
17067 #[allow(clippy::enum_variant_names)]
17068 enum GeneratedField {
17069 Id,
17070 ObjectType,
17071 }
17072 impl<'de> serde::Deserialize<'de> for GeneratedField {
17073 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17074 where
17075 D: serde::Deserializer<'de>,
17076 {
17077 struct GeneratedVisitor;
17078
17079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17080 type Value = GeneratedField;
17081
17082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17083 write!(formatter, "expected one of: {:?}", &FIELDS)
17084 }
17085
17086 #[allow(unused_variables)]
17087 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17088 where
17089 E: serde::de::Error,
17090 {
17091 match value {
17092 "id" => Ok(GeneratedField::Id),
17093 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
17094 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17095 }
17096 }
17097 }
17098 deserializer.deserialize_identifier(GeneratedVisitor)
17099 }
17100 }
17101 struct GeneratedVisitor;
17102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17103 type Value = VectorIndexObject;
17104
17105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17106 formatter.write_str("struct hummock.VectorIndexObject")
17107 }
17108
17109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
17110 where
17111 V: serde::de::MapAccess<'de>,
17112 {
17113 let mut id__ = None;
17114 let mut object_type__ = None;
17115 while let Some(k) = map_.next_key()? {
17116 match k {
17117 GeneratedField::Id => {
17118 if id__.is_some() {
17119 return Err(serde::de::Error::duplicate_field("id"));
17120 }
17121 id__ =
17122 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17123 ;
17124 }
17125 GeneratedField::ObjectType => {
17126 if object_type__.is_some() {
17127 return Err(serde::de::Error::duplicate_field("objectType"));
17128 }
17129 object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
17130 }
17131 }
17132 }
17133 Ok(VectorIndexObject {
17134 id: id__.unwrap_or_default(),
17135 object_type: object_type__.unwrap_or_default(),
17136 })
17137 }
17138 }
17139 deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
17140 }
17141}
17142impl serde::Serialize for VectorIndexObjectType {
17143 #[allow(deprecated)]
17144 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17145 where
17146 S: serde::Serializer,
17147 {
17148 let variant = match self {
17149 Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17150 Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
17151 };
17152 serializer.serialize_str(variant)
17153 }
17154}
17155impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
17156 #[allow(deprecated)]
17157 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17158 where
17159 D: serde::Deserializer<'de>,
17160 {
17161 const FIELDS: &[&str] = &[
17162 "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17163 "VECTOR_INDEX_OBJECT_VECTOR",
17164 ];
17165
17166 struct GeneratedVisitor;
17167
17168 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17169 type Value = VectorIndexObjectType;
17170
17171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17172 write!(formatter, "expected one of: {:?}", &FIELDS)
17173 }
17174
17175 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17176 where
17177 E: serde::de::Error,
17178 {
17179 i32::try_from(v)
17180 .ok()
17181 .and_then(|x| x.try_into().ok())
17182 .ok_or_else(|| {
17183 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17184 })
17185 }
17186
17187 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17188 where
17189 E: serde::de::Error,
17190 {
17191 i32::try_from(v)
17192 .ok()
17193 .and_then(|x| x.try_into().ok())
17194 .ok_or_else(|| {
17195 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17196 })
17197 }
17198
17199 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17200 where
17201 E: serde::de::Error,
17202 {
17203 match value {
17204 "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
17205 "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
17206 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17207 }
17208 }
17209 }
17210 deserializer.deserialize_any(GeneratedVisitor)
17211 }
17212}
17213impl serde::Serialize for VersionUpdatePayload {
17214 #[allow(deprecated)]
17215 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17216 where
17217 S: serde::Serializer,
17218 {
17219 use serde::ser::SerializeStruct;
17220 let mut len = 0;
17221 if self.payload.is_some() {
17222 len += 1;
17223 }
17224 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
17225 if let Some(v) = self.payload.as_ref() {
17226 match v {
17227 version_update_payload::Payload::VersionDeltas(v) => {
17228 struct_ser.serialize_field("versionDeltas", v)?;
17229 }
17230 version_update_payload::Payload::PinnedVersion(v) => {
17231 struct_ser.serialize_field("pinnedVersion", v)?;
17232 }
17233 }
17234 }
17235 struct_ser.end()
17236 }
17237}
17238impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
17239 #[allow(deprecated)]
17240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17241 where
17242 D: serde::Deserializer<'de>,
17243 {
17244 const FIELDS: &[&str] = &[
17245 "version_deltas",
17246 "versionDeltas",
17247 "pinned_version",
17248 "pinnedVersion",
17249 ];
17250
17251 #[allow(clippy::enum_variant_names)]
17252 enum GeneratedField {
17253 VersionDeltas,
17254 PinnedVersion,
17255 }
17256 impl<'de> serde::Deserialize<'de> for GeneratedField {
17257 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17258 where
17259 D: serde::Deserializer<'de>,
17260 {
17261 struct GeneratedVisitor;
17262
17263 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17264 type Value = GeneratedField;
17265
17266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17267 write!(formatter, "expected one of: {:?}", &FIELDS)
17268 }
17269
17270 #[allow(unused_variables)]
17271 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17272 where
17273 E: serde::de::Error,
17274 {
17275 match value {
17276 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
17277 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
17278 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17279 }
17280 }
17281 }
17282 deserializer.deserialize_identifier(GeneratedVisitor)
17283 }
17284 }
17285 struct GeneratedVisitor;
17286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17287 type Value = VersionUpdatePayload;
17288
17289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17290 formatter.write_str("struct hummock.VersionUpdatePayload")
17291 }
17292
17293 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
17294 where
17295 V: serde::de::MapAccess<'de>,
17296 {
17297 let mut payload__ = None;
17298 while let Some(k) = map_.next_key()? {
17299 match k {
17300 GeneratedField::VersionDeltas => {
17301 if payload__.is_some() {
17302 return Err(serde::de::Error::duplicate_field("versionDeltas"));
17303 }
17304 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
17305;
17306 }
17307 GeneratedField::PinnedVersion => {
17308 if payload__.is_some() {
17309 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
17310 }
17311 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
17312;
17313 }
17314 }
17315 }
17316 Ok(VersionUpdatePayload {
17317 payload: payload__,
17318 })
17319 }
17320 }
17321 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
17322 }
17323}
17324impl serde::Serialize for VnodeWatermark {
17325 #[allow(deprecated)]
17326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17327 where
17328 S: serde::Serializer,
17329 {
17330 use serde::ser::SerializeStruct;
17331 let mut len = 0;
17332 if !self.watermark.is_empty() {
17333 len += 1;
17334 }
17335 if self.vnode_bitmap.is_some() {
17336 len += 1;
17337 }
17338 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
17339 if !self.watermark.is_empty() {
17340 #[allow(clippy::needless_borrow)]
17341 #[allow(clippy::needless_borrows_for_generic_args)]
17342 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
17343 }
17344 if let Some(v) = self.vnode_bitmap.as_ref() {
17345 struct_ser.serialize_field("vnodeBitmap", v)?;
17346 }
17347 struct_ser.end()
17348 }
17349}
17350impl<'de> serde::Deserialize<'de> for VnodeWatermark {
17351 #[allow(deprecated)]
17352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17353 where
17354 D: serde::Deserializer<'de>,
17355 {
17356 const FIELDS: &[&str] = &[
17357 "watermark",
17358 "vnode_bitmap",
17359 "vnodeBitmap",
17360 ];
17361
17362 #[allow(clippy::enum_variant_names)]
17363 enum GeneratedField {
17364 Watermark,
17365 VnodeBitmap,
17366 }
17367 impl<'de> serde::Deserialize<'de> for GeneratedField {
17368 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17369 where
17370 D: serde::Deserializer<'de>,
17371 {
17372 struct GeneratedVisitor;
17373
17374 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17375 type Value = GeneratedField;
17376
17377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17378 write!(formatter, "expected one of: {:?}", &FIELDS)
17379 }
17380
17381 #[allow(unused_variables)]
17382 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17383 where
17384 E: serde::de::Error,
17385 {
17386 match value {
17387 "watermark" => Ok(GeneratedField::Watermark),
17388 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
17389 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17390 }
17391 }
17392 }
17393 deserializer.deserialize_identifier(GeneratedVisitor)
17394 }
17395 }
17396 struct GeneratedVisitor;
17397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17398 type Value = VnodeWatermark;
17399
17400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17401 formatter.write_str("struct hummock.VnodeWatermark")
17402 }
17403
17404 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
17405 where
17406 V: serde::de::MapAccess<'de>,
17407 {
17408 let mut watermark__ = None;
17409 let mut vnode_bitmap__ = None;
17410 while let Some(k) = map_.next_key()? {
17411 match k {
17412 GeneratedField::Watermark => {
17413 if watermark__.is_some() {
17414 return Err(serde::de::Error::duplicate_field("watermark"));
17415 }
17416 watermark__ =
17417 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
17418 ;
17419 }
17420 GeneratedField::VnodeBitmap => {
17421 if vnode_bitmap__.is_some() {
17422 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
17423 }
17424 vnode_bitmap__ = map_.next_value()?;
17425 }
17426 }
17427 }
17428 Ok(VnodeWatermark {
17429 watermark: watermark__.unwrap_or_default(),
17430 vnode_bitmap: vnode_bitmap__,
17431 })
17432 }
17433 }
17434 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
17435 }
17436}
17437impl serde::Serialize for WriteLimits {
17438 #[allow(deprecated)]
17439 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17440 where
17441 S: serde::Serializer,
17442 {
17443 use serde::ser::SerializeStruct;
17444 let mut len = 0;
17445 if !self.write_limits.is_empty() {
17446 len += 1;
17447 }
17448 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
17449 if !self.write_limits.is_empty() {
17450 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
17451 }
17452 struct_ser.end()
17453 }
17454}
17455impl<'de> serde::Deserialize<'de> for WriteLimits {
17456 #[allow(deprecated)]
17457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17458 where
17459 D: serde::Deserializer<'de>,
17460 {
17461 const FIELDS: &[&str] = &[
17462 "write_limits",
17463 "writeLimits",
17464 ];
17465
17466 #[allow(clippy::enum_variant_names)]
17467 enum GeneratedField {
17468 WriteLimits,
17469 }
17470 impl<'de> serde::Deserialize<'de> for GeneratedField {
17471 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17472 where
17473 D: serde::Deserializer<'de>,
17474 {
17475 struct GeneratedVisitor;
17476
17477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17478 type Value = GeneratedField;
17479
17480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17481 write!(formatter, "expected one of: {:?}", &FIELDS)
17482 }
17483
17484 #[allow(unused_variables)]
17485 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17486 where
17487 E: serde::de::Error,
17488 {
17489 match value {
17490 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
17491 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17492 }
17493 }
17494 }
17495 deserializer.deserialize_identifier(GeneratedVisitor)
17496 }
17497 }
17498 struct GeneratedVisitor;
17499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17500 type Value = WriteLimits;
17501
17502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17503 formatter.write_str("struct hummock.WriteLimits")
17504 }
17505
17506 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
17507 where
17508 V: serde::de::MapAccess<'de>,
17509 {
17510 let mut write_limits__ = None;
17511 while let Some(k) = map_.next_key()? {
17512 match k {
17513 GeneratedField::WriteLimits => {
17514 if write_limits__.is_some() {
17515 return Err(serde::de::Error::duplicate_field("writeLimits"));
17516 }
17517 write_limits__ = Some(
17518 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
17519 .into_iter().map(|(k,v)| (k.0, v)).collect()
17520 );
17521 }
17522 }
17523 }
17524 Ok(WriteLimits {
17525 write_limits: write_limits__.unwrap_or_default(),
17526 })
17527 }
17528 }
17529 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
17530 }
17531}
17532impl serde::Serialize for write_limits::WriteLimit {
17533 #[allow(deprecated)]
17534 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17535 where
17536 S: serde::Serializer,
17537 {
17538 use serde::ser::SerializeStruct;
17539 let mut len = 0;
17540 if !self.table_ids.is_empty() {
17541 len += 1;
17542 }
17543 if !self.reason.is_empty() {
17544 len += 1;
17545 }
17546 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
17547 if !self.table_ids.is_empty() {
17548 struct_ser.serialize_field("tableIds", &self.table_ids)?;
17549 }
17550 if !self.reason.is_empty() {
17551 struct_ser.serialize_field("reason", &self.reason)?;
17552 }
17553 struct_ser.end()
17554 }
17555}
17556impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
17557 #[allow(deprecated)]
17558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17559 where
17560 D: serde::Deserializer<'de>,
17561 {
17562 const FIELDS: &[&str] = &[
17563 "table_ids",
17564 "tableIds",
17565 "reason",
17566 ];
17567
17568 #[allow(clippy::enum_variant_names)]
17569 enum GeneratedField {
17570 TableIds,
17571 Reason,
17572 }
17573 impl<'de> serde::Deserialize<'de> for GeneratedField {
17574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17575 where
17576 D: serde::Deserializer<'de>,
17577 {
17578 struct GeneratedVisitor;
17579
17580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17581 type Value = GeneratedField;
17582
17583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17584 write!(formatter, "expected one of: {:?}", &FIELDS)
17585 }
17586
17587 #[allow(unused_variables)]
17588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17589 where
17590 E: serde::de::Error,
17591 {
17592 match value {
17593 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
17594 "reason" => Ok(GeneratedField::Reason),
17595 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17596 }
17597 }
17598 }
17599 deserializer.deserialize_identifier(GeneratedVisitor)
17600 }
17601 }
17602 struct GeneratedVisitor;
17603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17604 type Value = write_limits::WriteLimit;
17605
17606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17607 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
17608 }
17609
17610 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
17611 where
17612 V: serde::de::MapAccess<'de>,
17613 {
17614 let mut table_ids__ = None;
17615 let mut reason__ = None;
17616 while let Some(k) = map_.next_key()? {
17617 match k {
17618 GeneratedField::TableIds => {
17619 if table_ids__.is_some() {
17620 return Err(serde::de::Error::duplicate_field("tableIds"));
17621 }
17622 table_ids__ =
17623 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17624 .into_iter().map(|x| x.0).collect())
17625 ;
17626 }
17627 GeneratedField::Reason => {
17628 if reason__.is_some() {
17629 return Err(serde::de::Error::duplicate_field("reason"));
17630 }
17631 reason__ = Some(map_.next_value()?);
17632 }
17633 }
17634 }
17635 Ok(write_limits::WriteLimit {
17636 table_ids: table_ids__.unwrap_or_default(),
17637 reason: reason__.unwrap_or_default(),
17638 })
17639 }
17640 }
17641 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
17642 }
17643}