1use crate::hummock::*;
2impl serde::Serialize for BloomFilterType {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 let variant = match self {
9 Self::BloomFilterUnspecified => "BLOOM_FILTER_UNSPECIFIED",
10 Self::Sstable => "SSTABLE",
11 Self::Blocked => "BLOCKED",
12 };
13 serializer.serialize_str(variant)
14 }
15}
16impl<'de> serde::Deserialize<'de> for BloomFilterType {
17 #[allow(deprecated)]
18 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19 where
20 D: serde::Deserializer<'de>,
21 {
22 const FIELDS: &[&str] = &[
23 "BLOOM_FILTER_UNSPECIFIED",
24 "SSTABLE",
25 "BLOCKED",
26 ];
27
28 struct GeneratedVisitor;
29
30 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
31 type Value = BloomFilterType;
32
33 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34 write!(formatter, "expected one of: {:?}", &FIELDS)
35 }
36
37 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
38 where
39 E: serde::de::Error,
40 {
41 i32::try_from(v)
42 .ok()
43 .and_then(|x| x.try_into().ok())
44 .ok_or_else(|| {
45 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
46 })
47 }
48
49 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
50 where
51 E: serde::de::Error,
52 {
53 i32::try_from(v)
54 .ok()
55 .and_then(|x| x.try_into().ok())
56 .ok_or_else(|| {
57 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
58 })
59 }
60
61 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
62 where
63 E: serde::de::Error,
64 {
65 match value {
66 "BLOOM_FILTER_UNSPECIFIED" => Ok(BloomFilterType::BloomFilterUnspecified),
67 "SSTABLE" => Ok(BloomFilterType::Sstable),
68 "BLOCKED" => Ok(BloomFilterType::Blocked),
69 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
70 }
71 }
72 }
73 deserializer.deserialize_any(GeneratedVisitor)
74 }
75}
76impl serde::Serialize for BranchedObject {
77 #[allow(deprecated)]
78 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
79 where
80 S: serde::Serializer,
81 {
82 use serde::ser::SerializeStruct;
83 let mut len = 0;
84 if self.object_id != 0 {
85 len += 1;
86 }
87 if !self.sst_id.is_empty() {
88 len += 1;
89 }
90 if self.compaction_group_id != 0 {
91 len += 1;
92 }
93 let mut struct_ser = serializer.serialize_struct("hummock.BranchedObject", len)?;
94 if self.object_id != 0 {
95 #[allow(clippy::needless_borrow)]
96 #[allow(clippy::needless_borrows_for_generic_args)]
97 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
98 }
99 if !self.sst_id.is_empty() {
100 struct_ser.serialize_field("sstId", &self.sst_id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
101 }
102 if self.compaction_group_id != 0 {
103 #[allow(clippy::needless_borrow)]
104 #[allow(clippy::needless_borrows_for_generic_args)]
105 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
106 }
107 struct_ser.end()
108 }
109}
110impl<'de> serde::Deserialize<'de> for BranchedObject {
111 #[allow(deprecated)]
112 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
113 where
114 D: serde::Deserializer<'de>,
115 {
116 const FIELDS: &[&str] = &[
117 "object_id",
118 "objectId",
119 "sst_id",
120 "sstId",
121 "compaction_group_id",
122 "compactionGroupId",
123 ];
124
125 #[allow(clippy::enum_variant_names)]
126 enum GeneratedField {
127 ObjectId,
128 SstId,
129 CompactionGroupId,
130 }
131 impl<'de> serde::Deserialize<'de> for GeneratedField {
132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
133 where
134 D: serde::Deserializer<'de>,
135 {
136 struct GeneratedVisitor;
137
138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
139 type Value = GeneratedField;
140
141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
142 write!(formatter, "expected one of: {:?}", &FIELDS)
143 }
144
145 #[allow(unused_variables)]
146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
147 where
148 E: serde::de::Error,
149 {
150 match value {
151 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
152 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
153 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
155 }
156 }
157 }
158 deserializer.deserialize_identifier(GeneratedVisitor)
159 }
160 }
161 struct GeneratedVisitor;
162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
163 type Value = BranchedObject;
164
165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
166 formatter.write_str("struct hummock.BranchedObject")
167 }
168
169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BranchedObject, V::Error>
170 where
171 V: serde::de::MapAccess<'de>,
172 {
173 let mut object_id__ = None;
174 let mut sst_id__ = None;
175 let mut compaction_group_id__ = None;
176 while let Some(k) = map_.next_key()? {
177 match k {
178 GeneratedField::ObjectId => {
179 if object_id__.is_some() {
180 return Err(serde::de::Error::duplicate_field("objectId"));
181 }
182 object_id__ =
183 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
184 ;
185 }
186 GeneratedField::SstId => {
187 if sst_id__.is_some() {
188 return Err(serde::de::Error::duplicate_field("sstId"));
189 }
190 sst_id__ =
191 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
192 .into_iter().map(|x| x.0).collect())
193 ;
194 }
195 GeneratedField::CompactionGroupId => {
196 if compaction_group_id__.is_some() {
197 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
198 }
199 compaction_group_id__ =
200 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
201 ;
202 }
203 }
204 }
205 Ok(BranchedObject {
206 object_id: object_id__.unwrap_or_default(),
207 sst_id: sst_id__.unwrap_or_default(),
208 compaction_group_id: compaction_group_id__.unwrap_or_default(),
209 })
210 }
211 }
212 deserializer.deserialize_struct("hummock.BranchedObject", FIELDS, GeneratedVisitor)
213 }
214}
215impl serde::Serialize for CancelCompactTask {
216 #[allow(deprecated)]
217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
218 where
219 S: serde::Serializer,
220 {
221 use serde::ser::SerializeStruct;
222 let mut len = 0;
223 if self.context_id != 0 {
224 len += 1;
225 }
226 if self.task_id != 0 {
227 len += 1;
228 }
229 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTask", len)?;
230 if self.context_id != 0 {
231 struct_ser.serialize_field("contextId", &self.context_id)?;
232 }
233 if self.task_id != 0 {
234 #[allow(clippy::needless_borrow)]
235 #[allow(clippy::needless_borrows_for_generic_args)]
236 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
237 }
238 struct_ser.end()
239 }
240}
241impl<'de> serde::Deserialize<'de> for CancelCompactTask {
242 #[allow(deprecated)]
243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
244 where
245 D: serde::Deserializer<'de>,
246 {
247 const FIELDS: &[&str] = &[
248 "context_id",
249 "contextId",
250 "task_id",
251 "taskId",
252 ];
253
254 #[allow(clippy::enum_variant_names)]
255 enum GeneratedField {
256 ContextId,
257 TaskId,
258 }
259 impl<'de> serde::Deserialize<'de> for GeneratedField {
260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
261 where
262 D: serde::Deserializer<'de>,
263 {
264 struct GeneratedVisitor;
265
266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
267 type Value = GeneratedField;
268
269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270 write!(formatter, "expected one of: {:?}", &FIELDS)
271 }
272
273 #[allow(unused_variables)]
274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
275 where
276 E: serde::de::Error,
277 {
278 match value {
279 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
280 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
282 }
283 }
284 }
285 deserializer.deserialize_identifier(GeneratedVisitor)
286 }
287 }
288 struct GeneratedVisitor;
289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
290 type Value = CancelCompactTask;
291
292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
293 formatter.write_str("struct hummock.CancelCompactTask")
294 }
295
296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTask, V::Error>
297 where
298 V: serde::de::MapAccess<'de>,
299 {
300 let mut context_id__ = None;
301 let mut task_id__ = None;
302 while let Some(k) = map_.next_key()? {
303 match k {
304 GeneratedField::ContextId => {
305 if context_id__.is_some() {
306 return Err(serde::de::Error::duplicate_field("contextId"));
307 }
308 context_id__ =
309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
310 ;
311 }
312 GeneratedField::TaskId => {
313 if task_id__.is_some() {
314 return Err(serde::de::Error::duplicate_field("taskId"));
315 }
316 task_id__ =
317 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
318 ;
319 }
320 }
321 }
322 Ok(CancelCompactTask {
323 context_id: context_id__.unwrap_or_default(),
324 task_id: task_id__.unwrap_or_default(),
325 })
326 }
327 }
328 deserializer.deserialize_struct("hummock.CancelCompactTask", FIELDS, GeneratedVisitor)
329 }
330}
331impl serde::Serialize for CancelCompactTaskRequest {
332 #[allow(deprecated)]
333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
334 where
335 S: serde::Serializer,
336 {
337 use serde::ser::SerializeStruct;
338 let mut len = 0;
339 if self.task_id != 0 {
340 len += 1;
341 }
342 if self.task_status != 0 {
343 len += 1;
344 }
345 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskRequest", len)?;
346 if self.task_id != 0 {
347 #[allow(clippy::needless_borrow)]
348 #[allow(clippy::needless_borrows_for_generic_args)]
349 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
350 }
351 if self.task_status != 0 {
352 let v = compact_task::TaskStatus::try_from(self.task_status)
353 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
354 struct_ser.serialize_field("taskStatus", &v)?;
355 }
356 struct_ser.end()
357 }
358}
359impl<'de> serde::Deserialize<'de> for CancelCompactTaskRequest {
360 #[allow(deprecated)]
361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
362 where
363 D: serde::Deserializer<'de>,
364 {
365 const FIELDS: &[&str] = &[
366 "task_id",
367 "taskId",
368 "task_status",
369 "taskStatus",
370 ];
371
372 #[allow(clippy::enum_variant_names)]
373 enum GeneratedField {
374 TaskId,
375 TaskStatus,
376 }
377 impl<'de> serde::Deserialize<'de> for GeneratedField {
378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
379 where
380 D: serde::Deserializer<'de>,
381 {
382 struct GeneratedVisitor;
383
384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
385 type Value = GeneratedField;
386
387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
388 write!(formatter, "expected one of: {:?}", &FIELDS)
389 }
390
391 #[allow(unused_variables)]
392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
393 where
394 E: serde::de::Error,
395 {
396 match value {
397 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
398 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
400 }
401 }
402 }
403 deserializer.deserialize_identifier(GeneratedVisitor)
404 }
405 }
406 struct GeneratedVisitor;
407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
408 type Value = CancelCompactTaskRequest;
409
410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
411 formatter.write_str("struct hummock.CancelCompactTaskRequest")
412 }
413
414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskRequest, V::Error>
415 where
416 V: serde::de::MapAccess<'de>,
417 {
418 let mut task_id__ = None;
419 let mut task_status__ = None;
420 while let Some(k) = map_.next_key()? {
421 match k {
422 GeneratedField::TaskId => {
423 if task_id__.is_some() {
424 return Err(serde::de::Error::duplicate_field("taskId"));
425 }
426 task_id__ =
427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
428 ;
429 }
430 GeneratedField::TaskStatus => {
431 if task_status__.is_some() {
432 return Err(serde::de::Error::duplicate_field("taskStatus"));
433 }
434 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
435 }
436 }
437 }
438 Ok(CancelCompactTaskRequest {
439 task_id: task_id__.unwrap_or_default(),
440 task_status: task_status__.unwrap_or_default(),
441 })
442 }
443 }
444 deserializer.deserialize_struct("hummock.CancelCompactTaskRequest", FIELDS, GeneratedVisitor)
445 }
446}
447impl serde::Serialize for CancelCompactTaskResponse {
448 #[allow(deprecated)]
449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
450 where
451 S: serde::Serializer,
452 {
453 use serde::ser::SerializeStruct;
454 let mut len = 0;
455 if self.ret {
456 len += 1;
457 }
458 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskResponse", len)?;
459 if self.ret {
460 struct_ser.serialize_field("ret", &self.ret)?;
461 }
462 struct_ser.end()
463 }
464}
465impl<'de> serde::Deserialize<'de> for CancelCompactTaskResponse {
466 #[allow(deprecated)]
467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
468 where
469 D: serde::Deserializer<'de>,
470 {
471 const FIELDS: &[&str] = &[
472 "ret",
473 ];
474
475 #[allow(clippy::enum_variant_names)]
476 enum GeneratedField {
477 Ret,
478 }
479 impl<'de> serde::Deserialize<'de> for GeneratedField {
480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
481 where
482 D: serde::Deserializer<'de>,
483 {
484 struct GeneratedVisitor;
485
486 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
487 type Value = GeneratedField;
488
489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
490 write!(formatter, "expected one of: {:?}", &FIELDS)
491 }
492
493 #[allow(unused_variables)]
494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
495 where
496 E: serde::de::Error,
497 {
498 match value {
499 "ret" => Ok(GeneratedField::Ret),
500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
501 }
502 }
503 }
504 deserializer.deserialize_identifier(GeneratedVisitor)
505 }
506 }
507 struct GeneratedVisitor;
508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
509 type Value = CancelCompactTaskResponse;
510
511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
512 formatter.write_str("struct hummock.CancelCompactTaskResponse")
513 }
514
515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskResponse, V::Error>
516 where
517 V: serde::de::MapAccess<'de>,
518 {
519 let mut ret__ = None;
520 while let Some(k) = map_.next_key()? {
521 match k {
522 GeneratedField::Ret => {
523 if ret__.is_some() {
524 return Err(serde::de::Error::duplicate_field("ret"));
525 }
526 ret__ = Some(map_.next_value()?);
527 }
528 }
529 }
530 Ok(CancelCompactTaskResponse {
531 ret: ret__.unwrap_or_default(),
532 })
533 }
534 }
535 deserializer.deserialize_struct("hummock.CancelCompactTaskResponse", FIELDS, GeneratedVisitor)
536 }
537}
538impl serde::Serialize for CompactStatus {
539 #[allow(deprecated)]
540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
541 where
542 S: serde::Serializer,
543 {
544 use serde::ser::SerializeStruct;
545 let mut len = 0;
546 if self.compaction_group_id != 0 {
547 len += 1;
548 }
549 if !self.level_handlers.is_empty() {
550 len += 1;
551 }
552 let mut struct_ser = serializer.serialize_struct("hummock.CompactStatus", len)?;
553 if self.compaction_group_id != 0 {
554 #[allow(clippy::needless_borrow)]
555 #[allow(clippy::needless_borrows_for_generic_args)]
556 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
557 }
558 if !self.level_handlers.is_empty() {
559 struct_ser.serialize_field("levelHandlers", &self.level_handlers)?;
560 }
561 struct_ser.end()
562 }
563}
564impl<'de> serde::Deserialize<'de> for CompactStatus {
565 #[allow(deprecated)]
566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
567 where
568 D: serde::Deserializer<'de>,
569 {
570 const FIELDS: &[&str] = &[
571 "compaction_group_id",
572 "compactionGroupId",
573 "level_handlers",
574 "levelHandlers",
575 ];
576
577 #[allow(clippy::enum_variant_names)]
578 enum GeneratedField {
579 CompactionGroupId,
580 LevelHandlers,
581 }
582 impl<'de> serde::Deserialize<'de> for GeneratedField {
583 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
584 where
585 D: serde::Deserializer<'de>,
586 {
587 struct GeneratedVisitor;
588
589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
590 type Value = GeneratedField;
591
592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
593 write!(formatter, "expected one of: {:?}", &FIELDS)
594 }
595
596 #[allow(unused_variables)]
597 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
598 where
599 E: serde::de::Error,
600 {
601 match value {
602 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
603 "levelHandlers" | "level_handlers" => Ok(GeneratedField::LevelHandlers),
604 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
605 }
606 }
607 }
608 deserializer.deserialize_identifier(GeneratedVisitor)
609 }
610 }
611 struct GeneratedVisitor;
612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
613 type Value = CompactStatus;
614
615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
616 formatter.write_str("struct hummock.CompactStatus")
617 }
618
619 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactStatus, V::Error>
620 where
621 V: serde::de::MapAccess<'de>,
622 {
623 let mut compaction_group_id__ = None;
624 let mut level_handlers__ = None;
625 while let Some(k) = map_.next_key()? {
626 match k {
627 GeneratedField::CompactionGroupId => {
628 if compaction_group_id__.is_some() {
629 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
630 }
631 compaction_group_id__ =
632 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
633 ;
634 }
635 GeneratedField::LevelHandlers => {
636 if level_handlers__.is_some() {
637 return Err(serde::de::Error::duplicate_field("levelHandlers"));
638 }
639 level_handlers__ = Some(map_.next_value()?);
640 }
641 }
642 }
643 Ok(CompactStatus {
644 compaction_group_id: compaction_group_id__.unwrap_or_default(),
645 level_handlers: level_handlers__.unwrap_or_default(),
646 })
647 }
648 }
649 deserializer.deserialize_struct("hummock.CompactStatus", FIELDS, GeneratedVisitor)
650 }
651}
652impl serde::Serialize for CompactTask {
653 #[allow(deprecated)]
654 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
655 where
656 S: serde::Serializer,
657 {
658 use serde::ser::SerializeStruct;
659 let mut len = 0;
660 if !self.input_ssts.is_empty() {
661 len += 1;
662 }
663 if !self.splits.is_empty() {
664 len += 1;
665 }
666 if !self.sorted_output_ssts.is_empty() {
667 len += 1;
668 }
669 if self.task_id != 0 {
670 len += 1;
671 }
672 if self.target_level != 0 {
673 len += 1;
674 }
675 if self.gc_delete_keys {
676 len += 1;
677 }
678 if self.base_level != 0 {
679 len += 1;
680 }
681 if self.task_status != 0 {
682 len += 1;
683 }
684 if self.compaction_group_id != 0 {
685 len += 1;
686 }
687 if !self.existing_table_ids.is_empty() {
688 len += 1;
689 }
690 if self.compression_algorithm != 0 {
691 len += 1;
692 }
693 if self.target_file_size != 0 {
694 len += 1;
695 }
696 if self.compaction_filter_mask != 0 {
697 len += 1;
698 }
699 if !self.table_options.is_empty() {
700 len += 1;
701 }
702 if self.current_epoch_time != 0 {
703 len += 1;
704 }
705 if self.target_sub_level_id != 0 {
706 len += 1;
707 }
708 if self.task_type != 0 {
709 len += 1;
710 }
711 if self.split_by_state_table {
712 len += 1;
713 }
714 if self.split_weight_by_vnode != 0 {
715 len += 1;
716 }
717 if !self.table_vnode_partition.is_empty() {
718 len += 1;
719 }
720 if !self.table_watermarks.is_empty() {
721 len += 1;
722 }
723 if !self.table_schemas.is_empty() {
724 len += 1;
725 }
726 if self.max_sub_compaction != 0 {
727 len += 1;
728 }
729 if self.compaction_group_version_id != 0 {
730 len += 1;
731 }
732 let mut struct_ser = serializer.serialize_struct("hummock.CompactTask", len)?;
733 if !self.input_ssts.is_empty() {
734 struct_ser.serialize_field("inputSsts", &self.input_ssts)?;
735 }
736 if !self.splits.is_empty() {
737 struct_ser.serialize_field("splits", &self.splits)?;
738 }
739 if !self.sorted_output_ssts.is_empty() {
740 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
741 }
742 if self.task_id != 0 {
743 #[allow(clippy::needless_borrow)]
744 #[allow(clippy::needless_borrows_for_generic_args)]
745 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
746 }
747 if self.target_level != 0 {
748 struct_ser.serialize_field("targetLevel", &self.target_level)?;
749 }
750 if self.gc_delete_keys {
751 struct_ser.serialize_field("gcDeleteKeys", &self.gc_delete_keys)?;
752 }
753 if self.base_level != 0 {
754 struct_ser.serialize_field("baseLevel", &self.base_level)?;
755 }
756 if self.task_status != 0 {
757 let v = compact_task::TaskStatus::try_from(self.task_status)
758 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
759 struct_ser.serialize_field("taskStatus", &v)?;
760 }
761 if self.compaction_group_id != 0 {
762 #[allow(clippy::needless_borrow)]
763 #[allow(clippy::needless_borrows_for_generic_args)]
764 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
765 }
766 if !self.existing_table_ids.is_empty() {
767 struct_ser.serialize_field("existingTableIds", &self.existing_table_ids)?;
768 }
769 if self.compression_algorithm != 0 {
770 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
771 }
772 if self.target_file_size != 0 {
773 #[allow(clippy::needless_borrow)]
774 #[allow(clippy::needless_borrows_for_generic_args)]
775 struct_ser.serialize_field("targetFileSize", ToString::to_string(&self.target_file_size).as_str())?;
776 }
777 if self.compaction_filter_mask != 0 {
778 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
779 }
780 if !self.table_options.is_empty() {
781 struct_ser.serialize_field("tableOptions", &self.table_options)?;
782 }
783 if self.current_epoch_time != 0 {
784 #[allow(clippy::needless_borrow)]
785 #[allow(clippy::needless_borrows_for_generic_args)]
786 struct_ser.serialize_field("currentEpochTime", ToString::to_string(&self.current_epoch_time).as_str())?;
787 }
788 if self.target_sub_level_id != 0 {
789 #[allow(clippy::needless_borrow)]
790 #[allow(clippy::needless_borrows_for_generic_args)]
791 struct_ser.serialize_field("targetSubLevelId", ToString::to_string(&self.target_sub_level_id).as_str())?;
792 }
793 if self.task_type != 0 {
794 let v = compact_task::TaskType::try_from(self.task_type)
795 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_type)))?;
796 struct_ser.serialize_field("taskType", &v)?;
797 }
798 if self.split_by_state_table {
799 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
800 }
801 if self.split_weight_by_vnode != 0 {
802 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
803 }
804 if !self.table_vnode_partition.is_empty() {
805 struct_ser.serialize_field("tableVnodePartition", &self.table_vnode_partition)?;
806 }
807 if !self.table_watermarks.is_empty() {
808 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
809 }
810 if !self.table_schemas.is_empty() {
811 struct_ser.serialize_field("tableSchemas", &self.table_schemas)?;
812 }
813 if self.max_sub_compaction != 0 {
814 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
815 }
816 if self.compaction_group_version_id != 0 {
817 #[allow(clippy::needless_borrow)]
818 #[allow(clippy::needless_borrows_for_generic_args)]
819 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
820 }
821 struct_ser.end()
822 }
823}
824impl<'de> serde::Deserialize<'de> for CompactTask {
825 #[allow(deprecated)]
826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
827 where
828 D: serde::Deserializer<'de>,
829 {
830 const FIELDS: &[&str] = &[
831 "input_ssts",
832 "inputSsts",
833 "splits",
834 "sorted_output_ssts",
835 "sortedOutputSsts",
836 "task_id",
837 "taskId",
838 "target_level",
839 "targetLevel",
840 "gc_delete_keys",
841 "gcDeleteKeys",
842 "base_level",
843 "baseLevel",
844 "task_status",
845 "taskStatus",
846 "compaction_group_id",
847 "compactionGroupId",
848 "existing_table_ids",
849 "existingTableIds",
850 "compression_algorithm",
851 "compressionAlgorithm",
852 "target_file_size",
853 "targetFileSize",
854 "compaction_filter_mask",
855 "compactionFilterMask",
856 "table_options",
857 "tableOptions",
858 "current_epoch_time",
859 "currentEpochTime",
860 "target_sub_level_id",
861 "targetSubLevelId",
862 "task_type",
863 "taskType",
864 "split_by_state_table",
865 "splitByStateTable",
866 "split_weight_by_vnode",
867 "splitWeightByVnode",
868 "table_vnode_partition",
869 "tableVnodePartition",
870 "table_watermarks",
871 "tableWatermarks",
872 "table_schemas",
873 "tableSchemas",
874 "max_sub_compaction",
875 "maxSubCompaction",
876 "compaction_group_version_id",
877 "compactionGroupVersionId",
878 ];
879
880 #[allow(clippy::enum_variant_names)]
881 enum GeneratedField {
882 InputSsts,
883 Splits,
884 SortedOutputSsts,
885 TaskId,
886 TargetLevel,
887 GcDeleteKeys,
888 BaseLevel,
889 TaskStatus,
890 CompactionGroupId,
891 ExistingTableIds,
892 CompressionAlgorithm,
893 TargetFileSize,
894 CompactionFilterMask,
895 TableOptions,
896 CurrentEpochTime,
897 TargetSubLevelId,
898 TaskType,
899 SplitByStateTable,
900 SplitWeightByVnode,
901 TableVnodePartition,
902 TableWatermarks,
903 TableSchemas,
904 MaxSubCompaction,
905 CompactionGroupVersionId,
906 }
907 impl<'de> serde::Deserialize<'de> for GeneratedField {
908 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
909 where
910 D: serde::Deserializer<'de>,
911 {
912 struct GeneratedVisitor;
913
914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
915 type Value = GeneratedField;
916
917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
918 write!(formatter, "expected one of: {:?}", &FIELDS)
919 }
920
921 #[allow(unused_variables)]
922 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
923 where
924 E: serde::de::Error,
925 {
926 match value {
927 "inputSsts" | "input_ssts" => Ok(GeneratedField::InputSsts),
928 "splits" => Ok(GeneratedField::Splits),
929 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
930 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
931 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
932 "gcDeleteKeys" | "gc_delete_keys" => Ok(GeneratedField::GcDeleteKeys),
933 "baseLevel" | "base_level" => Ok(GeneratedField::BaseLevel),
934 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
935 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
936 "existingTableIds" | "existing_table_ids" => Ok(GeneratedField::ExistingTableIds),
937 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
938 "targetFileSize" | "target_file_size" => Ok(GeneratedField::TargetFileSize),
939 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
940 "tableOptions" | "table_options" => Ok(GeneratedField::TableOptions),
941 "currentEpochTime" | "current_epoch_time" => Ok(GeneratedField::CurrentEpochTime),
942 "targetSubLevelId" | "target_sub_level_id" => Ok(GeneratedField::TargetSubLevelId),
943 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
944 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
945 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
946 "tableVnodePartition" | "table_vnode_partition" => Ok(GeneratedField::TableVnodePartition),
947 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
948 "tableSchemas" | "table_schemas" => Ok(GeneratedField::TableSchemas),
949 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
950 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
952 }
953 }
954 }
955 deserializer.deserialize_identifier(GeneratedVisitor)
956 }
957 }
958 struct GeneratedVisitor;
959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
960 type Value = CompactTask;
961
962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
963 formatter.write_str("struct hummock.CompactTask")
964 }
965
966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTask, V::Error>
967 where
968 V: serde::de::MapAccess<'de>,
969 {
970 let mut input_ssts__ = None;
971 let mut splits__ = None;
972 let mut sorted_output_ssts__ = None;
973 let mut task_id__ = None;
974 let mut target_level__ = None;
975 let mut gc_delete_keys__ = None;
976 let mut base_level__ = None;
977 let mut task_status__ = None;
978 let mut compaction_group_id__ = None;
979 let mut existing_table_ids__ = None;
980 let mut compression_algorithm__ = None;
981 let mut target_file_size__ = None;
982 let mut compaction_filter_mask__ = None;
983 let mut table_options__ = None;
984 let mut current_epoch_time__ = None;
985 let mut target_sub_level_id__ = None;
986 let mut task_type__ = None;
987 let mut split_by_state_table__ = None;
988 let mut split_weight_by_vnode__ = None;
989 let mut table_vnode_partition__ = None;
990 let mut table_watermarks__ = None;
991 let mut table_schemas__ = None;
992 let mut max_sub_compaction__ = None;
993 let mut compaction_group_version_id__ = None;
994 while let Some(k) = map_.next_key()? {
995 match k {
996 GeneratedField::InputSsts => {
997 if input_ssts__.is_some() {
998 return Err(serde::de::Error::duplicate_field("inputSsts"));
999 }
1000 input_ssts__ = Some(map_.next_value()?);
1001 }
1002 GeneratedField::Splits => {
1003 if splits__.is_some() {
1004 return Err(serde::de::Error::duplicate_field("splits"));
1005 }
1006 splits__ = Some(map_.next_value()?);
1007 }
1008 GeneratedField::SortedOutputSsts => {
1009 if sorted_output_ssts__.is_some() {
1010 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
1011 }
1012 sorted_output_ssts__ = Some(map_.next_value()?);
1013 }
1014 GeneratedField::TaskId => {
1015 if task_id__.is_some() {
1016 return Err(serde::de::Error::duplicate_field("taskId"));
1017 }
1018 task_id__ =
1019 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1020 ;
1021 }
1022 GeneratedField::TargetLevel => {
1023 if target_level__.is_some() {
1024 return Err(serde::de::Error::duplicate_field("targetLevel"));
1025 }
1026 target_level__ =
1027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1028 ;
1029 }
1030 GeneratedField::GcDeleteKeys => {
1031 if gc_delete_keys__.is_some() {
1032 return Err(serde::de::Error::duplicate_field("gcDeleteKeys"));
1033 }
1034 gc_delete_keys__ = Some(map_.next_value()?);
1035 }
1036 GeneratedField::BaseLevel => {
1037 if base_level__.is_some() {
1038 return Err(serde::de::Error::duplicate_field("baseLevel"));
1039 }
1040 base_level__ =
1041 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1042 ;
1043 }
1044 GeneratedField::TaskStatus => {
1045 if task_status__.is_some() {
1046 return Err(serde::de::Error::duplicate_field("taskStatus"));
1047 }
1048 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
1049 }
1050 GeneratedField::CompactionGroupId => {
1051 if compaction_group_id__.is_some() {
1052 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1053 }
1054 compaction_group_id__ =
1055 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1056 ;
1057 }
1058 GeneratedField::ExistingTableIds => {
1059 if existing_table_ids__.is_some() {
1060 return Err(serde::de::Error::duplicate_field("existingTableIds"));
1061 }
1062 existing_table_ids__ =
1063 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1064 .into_iter().map(|x| x.0).collect())
1065 ;
1066 }
1067 GeneratedField::CompressionAlgorithm => {
1068 if compression_algorithm__.is_some() {
1069 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
1070 }
1071 compression_algorithm__ =
1072 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1073 ;
1074 }
1075 GeneratedField::TargetFileSize => {
1076 if target_file_size__.is_some() {
1077 return Err(serde::de::Error::duplicate_field("targetFileSize"));
1078 }
1079 target_file_size__ =
1080 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1081 ;
1082 }
1083 GeneratedField::CompactionFilterMask => {
1084 if compaction_filter_mask__.is_some() {
1085 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
1086 }
1087 compaction_filter_mask__ =
1088 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1089 ;
1090 }
1091 GeneratedField::TableOptions => {
1092 if table_options__.is_some() {
1093 return Err(serde::de::Error::duplicate_field("tableOptions"));
1094 }
1095 table_options__ = Some(
1096 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1097 .into_iter().map(|(k,v)| (k.0, v)).collect()
1098 );
1099 }
1100 GeneratedField::CurrentEpochTime => {
1101 if current_epoch_time__.is_some() {
1102 return Err(serde::de::Error::duplicate_field("currentEpochTime"));
1103 }
1104 current_epoch_time__ =
1105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1106 ;
1107 }
1108 GeneratedField::TargetSubLevelId => {
1109 if target_sub_level_id__.is_some() {
1110 return Err(serde::de::Error::duplicate_field("targetSubLevelId"));
1111 }
1112 target_sub_level_id__ =
1113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1114 ;
1115 }
1116 GeneratedField::TaskType => {
1117 if task_type__.is_some() {
1118 return Err(serde::de::Error::duplicate_field("taskType"));
1119 }
1120 task_type__ = Some(map_.next_value::<compact_task::TaskType>()? as i32);
1121 }
1122 GeneratedField::SplitByStateTable => {
1123 if split_by_state_table__.is_some() {
1124 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
1125 }
1126 split_by_state_table__ = Some(map_.next_value()?);
1127 }
1128 GeneratedField::SplitWeightByVnode => {
1129 if split_weight_by_vnode__.is_some() {
1130 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
1131 }
1132 split_weight_by_vnode__ =
1133 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1134 ;
1135 }
1136 GeneratedField::TableVnodePartition => {
1137 if table_vnode_partition__.is_some() {
1138 return Err(serde::de::Error::duplicate_field("tableVnodePartition"));
1139 }
1140 table_vnode_partition__ = Some(
1141 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
1142 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
1143 );
1144 }
1145 GeneratedField::TableWatermarks => {
1146 if table_watermarks__.is_some() {
1147 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
1148 }
1149 table_watermarks__ = Some(
1150 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1151 .into_iter().map(|(k,v)| (k.0, v)).collect()
1152 );
1153 }
1154 GeneratedField::TableSchemas => {
1155 if table_schemas__.is_some() {
1156 return Err(serde::de::Error::duplicate_field("tableSchemas"));
1157 }
1158 table_schemas__ = Some(
1159 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1160 .into_iter().map(|(k,v)| (k.0, v)).collect()
1161 );
1162 }
1163 GeneratedField::MaxSubCompaction => {
1164 if max_sub_compaction__.is_some() {
1165 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
1166 }
1167 max_sub_compaction__ =
1168 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1169 ;
1170 }
1171 GeneratedField::CompactionGroupVersionId => {
1172 if compaction_group_version_id__.is_some() {
1173 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
1174 }
1175 compaction_group_version_id__ =
1176 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1177 ;
1178 }
1179 }
1180 }
1181 Ok(CompactTask {
1182 input_ssts: input_ssts__.unwrap_or_default(),
1183 splits: splits__.unwrap_or_default(),
1184 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
1185 task_id: task_id__.unwrap_or_default(),
1186 target_level: target_level__.unwrap_or_default(),
1187 gc_delete_keys: gc_delete_keys__.unwrap_or_default(),
1188 base_level: base_level__.unwrap_or_default(),
1189 task_status: task_status__.unwrap_or_default(),
1190 compaction_group_id: compaction_group_id__.unwrap_or_default(),
1191 existing_table_ids: existing_table_ids__.unwrap_or_default(),
1192 compression_algorithm: compression_algorithm__.unwrap_or_default(),
1193 target_file_size: target_file_size__.unwrap_or_default(),
1194 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
1195 table_options: table_options__.unwrap_or_default(),
1196 current_epoch_time: current_epoch_time__.unwrap_or_default(),
1197 target_sub_level_id: target_sub_level_id__.unwrap_or_default(),
1198 task_type: task_type__.unwrap_or_default(),
1199 split_by_state_table: split_by_state_table__.unwrap_or_default(),
1200 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
1201 table_vnode_partition: table_vnode_partition__.unwrap_or_default(),
1202 table_watermarks: table_watermarks__.unwrap_or_default(),
1203 table_schemas: table_schemas__.unwrap_or_default(),
1204 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
1205 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
1206 })
1207 }
1208 }
1209 deserializer.deserialize_struct("hummock.CompactTask", FIELDS, GeneratedVisitor)
1210 }
1211}
1212impl serde::Serialize for compact_task::TaskStatus {
1213 #[allow(deprecated)]
1214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1215 where
1216 S: serde::Serializer,
1217 {
1218 let variant = match self {
1219 Self::Unspecified => "UNSPECIFIED",
1220 Self::Pending => "PENDING",
1221 Self::Success => "SUCCESS",
1222 Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
1223 Self::NoAvailMemoryResourceCanceled => "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1224 Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
1225 Self::SendFailCanceled => "SEND_FAIL_CANCELED",
1226 Self::ManualCanceled => "MANUAL_CANCELED",
1227 Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
1228 Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
1229 Self::ExecuteFailed => "EXECUTE_FAILED",
1230 Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
1231 Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
1232 Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
1233 Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
1234 Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
1235 Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
1236 Self::ServerlessTableNotFoundCanceled => "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1237 };
1238 serializer.serialize_str(variant)
1239 }
1240}
1241impl<'de> serde::Deserialize<'de> for compact_task::TaskStatus {
1242 #[allow(deprecated)]
1243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1244 where
1245 D: serde::Deserializer<'de>,
1246 {
1247 const FIELDS: &[&str] = &[
1248 "UNSPECIFIED",
1249 "PENDING",
1250 "SUCCESS",
1251 "HEARTBEAT_CANCELED",
1252 "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1253 "ASSIGN_FAIL_CANCELED",
1254 "SEND_FAIL_CANCELED",
1255 "MANUAL_CANCELED",
1256 "INVALID_GROUP_CANCELED",
1257 "INPUT_OUTDATED_CANCELED",
1258 "EXECUTE_FAILED",
1259 "JOIN_HANDLE_FAILED",
1260 "TRACK_SST_OBJECT_ID_FAILED",
1261 "NO_AVAIL_CPU_RESOURCE_CANCELED",
1262 "HEARTBEAT_PROGRESS_CANCELED",
1263 "RETENTION_TIME_REJECTED",
1264 "SERVERLESS_SEND_FAIL_CANCELED",
1265 "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1266 ];
1267
1268 struct GeneratedVisitor;
1269
1270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1271 type Value = compact_task::TaskStatus;
1272
1273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1274 write!(formatter, "expected one of: {:?}", &FIELDS)
1275 }
1276
1277 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1278 where
1279 E: serde::de::Error,
1280 {
1281 i32::try_from(v)
1282 .ok()
1283 .and_then(|x| x.try_into().ok())
1284 .ok_or_else(|| {
1285 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1286 })
1287 }
1288
1289 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1290 where
1291 E: serde::de::Error,
1292 {
1293 i32::try_from(v)
1294 .ok()
1295 .and_then(|x| x.try_into().ok())
1296 .ok_or_else(|| {
1297 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1298 })
1299 }
1300
1301 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1302 where
1303 E: serde::de::Error,
1304 {
1305 match value {
1306 "UNSPECIFIED" => Ok(compact_task::TaskStatus::Unspecified),
1307 "PENDING" => Ok(compact_task::TaskStatus::Pending),
1308 "SUCCESS" => Ok(compact_task::TaskStatus::Success),
1309 "HEARTBEAT_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatCanceled),
1310 "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailMemoryResourceCanceled),
1311 "ASSIGN_FAIL_CANCELED" => Ok(compact_task::TaskStatus::AssignFailCanceled),
1312 "SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::SendFailCanceled),
1313 "MANUAL_CANCELED" => Ok(compact_task::TaskStatus::ManualCanceled),
1314 "INVALID_GROUP_CANCELED" => Ok(compact_task::TaskStatus::InvalidGroupCanceled),
1315 "INPUT_OUTDATED_CANCELED" => Ok(compact_task::TaskStatus::InputOutdatedCanceled),
1316 "EXECUTE_FAILED" => Ok(compact_task::TaskStatus::ExecuteFailed),
1317 "JOIN_HANDLE_FAILED" => Ok(compact_task::TaskStatus::JoinHandleFailed),
1318 "TRACK_SST_OBJECT_ID_FAILED" => Ok(compact_task::TaskStatus::TrackSstObjectIdFailed),
1319 "NO_AVAIL_CPU_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailCpuResourceCanceled),
1320 "HEARTBEAT_PROGRESS_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatProgressCanceled),
1321 "RETENTION_TIME_REJECTED" => Ok(compact_task::TaskStatus::RetentionTimeRejected),
1322 "SERVERLESS_SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::ServerlessSendFailCanceled),
1323 "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => Ok(compact_task::TaskStatus::ServerlessTableNotFoundCanceled),
1324 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1325 }
1326 }
1327 }
1328 deserializer.deserialize_any(GeneratedVisitor)
1329 }
1330}
1331impl serde::Serialize for compact_task::TaskType {
1332 #[allow(deprecated)]
1333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1334 where
1335 S: serde::Serializer,
1336 {
1337 let variant = match self {
1338 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1339 Self::Dynamic => "DYNAMIC",
1340 Self::SpaceReclaim => "SPACE_RECLAIM",
1341 Self::Manual => "MANUAL",
1342 Self::SharedBuffer => "SHARED_BUFFER",
1343 Self::Ttl => "TTL",
1344 Self::Tombstone => "TOMBSTONE",
1345 Self::Emergency => "EMERGENCY",
1346 Self::VnodeWatermark => "VNODE_WATERMARK",
1347 };
1348 serializer.serialize_str(variant)
1349 }
1350}
1351impl<'de> serde::Deserialize<'de> for compact_task::TaskType {
1352 #[allow(deprecated)]
1353 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1354 where
1355 D: serde::Deserializer<'de>,
1356 {
1357 const FIELDS: &[&str] = &[
1358 "TYPE_UNSPECIFIED",
1359 "DYNAMIC",
1360 "SPACE_RECLAIM",
1361 "MANUAL",
1362 "SHARED_BUFFER",
1363 "TTL",
1364 "TOMBSTONE",
1365 "EMERGENCY",
1366 "VNODE_WATERMARK",
1367 ];
1368
1369 struct GeneratedVisitor;
1370
1371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1372 type Value = compact_task::TaskType;
1373
1374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1375 write!(formatter, "expected one of: {:?}", &FIELDS)
1376 }
1377
1378 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1379 where
1380 E: serde::de::Error,
1381 {
1382 i32::try_from(v)
1383 .ok()
1384 .and_then(|x| x.try_into().ok())
1385 .ok_or_else(|| {
1386 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1387 })
1388 }
1389
1390 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1391 where
1392 E: serde::de::Error,
1393 {
1394 i32::try_from(v)
1395 .ok()
1396 .and_then(|x| x.try_into().ok())
1397 .ok_or_else(|| {
1398 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1399 })
1400 }
1401
1402 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1403 where
1404 E: serde::de::Error,
1405 {
1406 match value {
1407 "TYPE_UNSPECIFIED" => Ok(compact_task::TaskType::TypeUnspecified),
1408 "DYNAMIC" => Ok(compact_task::TaskType::Dynamic),
1409 "SPACE_RECLAIM" => Ok(compact_task::TaskType::SpaceReclaim),
1410 "MANUAL" => Ok(compact_task::TaskType::Manual),
1411 "SHARED_BUFFER" => Ok(compact_task::TaskType::SharedBuffer),
1412 "TTL" => Ok(compact_task::TaskType::Ttl),
1413 "TOMBSTONE" => Ok(compact_task::TaskType::Tombstone),
1414 "EMERGENCY" => Ok(compact_task::TaskType::Emergency),
1415 "VNODE_WATERMARK" => Ok(compact_task::TaskType::VnodeWatermark),
1416 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1417 }
1418 }
1419 }
1420 deserializer.deserialize_any(GeneratedVisitor)
1421 }
1422}
1423impl serde::Serialize for CompactTaskAssignment {
1424 #[allow(deprecated)]
1425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1426 where
1427 S: serde::Serializer,
1428 {
1429 use serde::ser::SerializeStruct;
1430 let mut len = 0;
1431 if self.compact_task.is_some() {
1432 len += 1;
1433 }
1434 if self.context_id != 0 {
1435 len += 1;
1436 }
1437 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskAssignment", len)?;
1438 if let Some(v) = self.compact_task.as_ref() {
1439 struct_ser.serialize_field("compactTask", v)?;
1440 }
1441 if self.context_id != 0 {
1442 struct_ser.serialize_field("contextId", &self.context_id)?;
1443 }
1444 struct_ser.end()
1445 }
1446}
1447impl<'de> serde::Deserialize<'de> for CompactTaskAssignment {
1448 #[allow(deprecated)]
1449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1450 where
1451 D: serde::Deserializer<'de>,
1452 {
1453 const FIELDS: &[&str] = &[
1454 "compact_task",
1455 "compactTask",
1456 "context_id",
1457 "contextId",
1458 ];
1459
1460 #[allow(clippy::enum_variant_names)]
1461 enum GeneratedField {
1462 CompactTask,
1463 ContextId,
1464 }
1465 impl<'de> serde::Deserialize<'de> for GeneratedField {
1466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1467 where
1468 D: serde::Deserializer<'de>,
1469 {
1470 struct GeneratedVisitor;
1471
1472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1473 type Value = GeneratedField;
1474
1475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1476 write!(formatter, "expected one of: {:?}", &FIELDS)
1477 }
1478
1479 #[allow(unused_variables)]
1480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1481 where
1482 E: serde::de::Error,
1483 {
1484 match value {
1485 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
1486 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
1487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1488 }
1489 }
1490 }
1491 deserializer.deserialize_identifier(GeneratedVisitor)
1492 }
1493 }
1494 struct GeneratedVisitor;
1495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1496 type Value = CompactTaskAssignment;
1497
1498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1499 formatter.write_str("struct hummock.CompactTaskAssignment")
1500 }
1501
1502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskAssignment, V::Error>
1503 where
1504 V: serde::de::MapAccess<'de>,
1505 {
1506 let mut compact_task__ = None;
1507 let mut context_id__ = None;
1508 while let Some(k) = map_.next_key()? {
1509 match k {
1510 GeneratedField::CompactTask => {
1511 if compact_task__.is_some() {
1512 return Err(serde::de::Error::duplicate_field("compactTask"));
1513 }
1514 compact_task__ = map_.next_value()?;
1515 }
1516 GeneratedField::ContextId => {
1517 if context_id__.is_some() {
1518 return Err(serde::de::Error::duplicate_field("contextId"));
1519 }
1520 context_id__ =
1521 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1522 ;
1523 }
1524 }
1525 }
1526 Ok(CompactTaskAssignment {
1527 compact_task: compact_task__,
1528 context_id: context_id__.unwrap_or_default(),
1529 })
1530 }
1531 }
1532 deserializer.deserialize_struct("hummock.CompactTaskAssignment", FIELDS, GeneratedVisitor)
1533 }
1534}
1535impl serde::Serialize for CompactTaskProgress {
1536 #[allow(deprecated)]
1537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1538 where
1539 S: serde::Serializer,
1540 {
1541 use serde::ser::SerializeStruct;
1542 let mut len = 0;
1543 if self.task_id != 0 {
1544 len += 1;
1545 }
1546 if self.num_ssts_sealed != 0 {
1547 len += 1;
1548 }
1549 if self.num_ssts_uploaded != 0 {
1550 len += 1;
1551 }
1552 if self.num_progress_key != 0 {
1553 len += 1;
1554 }
1555 if self.num_pending_read_io != 0 {
1556 len += 1;
1557 }
1558 if self.num_pending_write_io != 0 {
1559 len += 1;
1560 }
1561 if self.compaction_group_id.is_some() {
1562 len += 1;
1563 }
1564 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskProgress", len)?;
1565 if self.task_id != 0 {
1566 #[allow(clippy::needless_borrow)]
1567 #[allow(clippy::needless_borrows_for_generic_args)]
1568 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
1569 }
1570 if self.num_ssts_sealed != 0 {
1571 struct_ser.serialize_field("numSstsSealed", &self.num_ssts_sealed)?;
1572 }
1573 if self.num_ssts_uploaded != 0 {
1574 struct_ser.serialize_field("numSstsUploaded", &self.num_ssts_uploaded)?;
1575 }
1576 if self.num_progress_key != 0 {
1577 #[allow(clippy::needless_borrow)]
1578 #[allow(clippy::needless_borrows_for_generic_args)]
1579 struct_ser.serialize_field("numProgressKey", ToString::to_string(&self.num_progress_key).as_str())?;
1580 }
1581 if self.num_pending_read_io != 0 {
1582 #[allow(clippy::needless_borrow)]
1583 #[allow(clippy::needless_borrows_for_generic_args)]
1584 struct_ser.serialize_field("numPendingReadIo", ToString::to_string(&self.num_pending_read_io).as_str())?;
1585 }
1586 if self.num_pending_write_io != 0 {
1587 #[allow(clippy::needless_borrow)]
1588 #[allow(clippy::needless_borrows_for_generic_args)]
1589 struct_ser.serialize_field("numPendingWriteIo", ToString::to_string(&self.num_pending_write_io).as_str())?;
1590 }
1591 if let Some(v) = self.compaction_group_id.as_ref() {
1592 #[allow(clippy::needless_borrow)]
1593 #[allow(clippy::needless_borrows_for_generic_args)]
1594 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&v).as_str())?;
1595 }
1596 struct_ser.end()
1597 }
1598}
1599impl<'de> serde::Deserialize<'de> for CompactTaskProgress {
1600 #[allow(deprecated)]
1601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1602 where
1603 D: serde::Deserializer<'de>,
1604 {
1605 const FIELDS: &[&str] = &[
1606 "task_id",
1607 "taskId",
1608 "num_ssts_sealed",
1609 "numSstsSealed",
1610 "num_ssts_uploaded",
1611 "numSstsUploaded",
1612 "num_progress_key",
1613 "numProgressKey",
1614 "num_pending_read_io",
1615 "numPendingReadIo",
1616 "num_pending_write_io",
1617 "numPendingWriteIo",
1618 "compaction_group_id",
1619 "compactionGroupId",
1620 ];
1621
1622 #[allow(clippy::enum_variant_names)]
1623 enum GeneratedField {
1624 TaskId,
1625 NumSstsSealed,
1626 NumSstsUploaded,
1627 NumProgressKey,
1628 NumPendingReadIo,
1629 NumPendingWriteIo,
1630 CompactionGroupId,
1631 }
1632 impl<'de> serde::Deserialize<'de> for GeneratedField {
1633 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1634 where
1635 D: serde::Deserializer<'de>,
1636 {
1637 struct GeneratedVisitor;
1638
1639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1640 type Value = GeneratedField;
1641
1642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1643 write!(formatter, "expected one of: {:?}", &FIELDS)
1644 }
1645
1646 #[allow(unused_variables)]
1647 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1648 where
1649 E: serde::de::Error,
1650 {
1651 match value {
1652 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1653 "numSstsSealed" | "num_ssts_sealed" => Ok(GeneratedField::NumSstsSealed),
1654 "numSstsUploaded" | "num_ssts_uploaded" => Ok(GeneratedField::NumSstsUploaded),
1655 "numProgressKey" | "num_progress_key" => Ok(GeneratedField::NumProgressKey),
1656 "numPendingReadIo" | "num_pending_read_io" => Ok(GeneratedField::NumPendingReadIo),
1657 "numPendingWriteIo" | "num_pending_write_io" => Ok(GeneratedField::NumPendingWriteIo),
1658 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1660 }
1661 }
1662 }
1663 deserializer.deserialize_identifier(GeneratedVisitor)
1664 }
1665 }
1666 struct GeneratedVisitor;
1667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1668 type Value = CompactTaskProgress;
1669
1670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1671 formatter.write_str("struct hummock.CompactTaskProgress")
1672 }
1673
1674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskProgress, V::Error>
1675 where
1676 V: serde::de::MapAccess<'de>,
1677 {
1678 let mut task_id__ = None;
1679 let mut num_ssts_sealed__ = None;
1680 let mut num_ssts_uploaded__ = None;
1681 let mut num_progress_key__ = None;
1682 let mut num_pending_read_io__ = None;
1683 let mut num_pending_write_io__ = None;
1684 let mut compaction_group_id__ = None;
1685 while let Some(k) = map_.next_key()? {
1686 match k {
1687 GeneratedField::TaskId => {
1688 if task_id__.is_some() {
1689 return Err(serde::de::Error::duplicate_field("taskId"));
1690 }
1691 task_id__ =
1692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1693 ;
1694 }
1695 GeneratedField::NumSstsSealed => {
1696 if num_ssts_sealed__.is_some() {
1697 return Err(serde::de::Error::duplicate_field("numSstsSealed"));
1698 }
1699 num_ssts_sealed__ =
1700 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1701 ;
1702 }
1703 GeneratedField::NumSstsUploaded => {
1704 if num_ssts_uploaded__.is_some() {
1705 return Err(serde::de::Error::duplicate_field("numSstsUploaded"));
1706 }
1707 num_ssts_uploaded__ =
1708 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1709 ;
1710 }
1711 GeneratedField::NumProgressKey => {
1712 if num_progress_key__.is_some() {
1713 return Err(serde::de::Error::duplicate_field("numProgressKey"));
1714 }
1715 num_progress_key__ =
1716 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1717 ;
1718 }
1719 GeneratedField::NumPendingReadIo => {
1720 if num_pending_read_io__.is_some() {
1721 return Err(serde::de::Error::duplicate_field("numPendingReadIo"));
1722 }
1723 num_pending_read_io__ =
1724 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1725 ;
1726 }
1727 GeneratedField::NumPendingWriteIo => {
1728 if num_pending_write_io__.is_some() {
1729 return Err(serde::de::Error::duplicate_field("numPendingWriteIo"));
1730 }
1731 num_pending_write_io__ =
1732 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1733 ;
1734 }
1735 GeneratedField::CompactionGroupId => {
1736 if compaction_group_id__.is_some() {
1737 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1738 }
1739 compaction_group_id__ =
1740 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1741 ;
1742 }
1743 }
1744 }
1745 Ok(CompactTaskProgress {
1746 task_id: task_id__.unwrap_or_default(),
1747 num_ssts_sealed: num_ssts_sealed__.unwrap_or_default(),
1748 num_ssts_uploaded: num_ssts_uploaded__.unwrap_or_default(),
1749 num_progress_key: num_progress_key__.unwrap_or_default(),
1750 num_pending_read_io: num_pending_read_io__.unwrap_or_default(),
1751 num_pending_write_io: num_pending_write_io__.unwrap_or_default(),
1752 compaction_group_id: compaction_group_id__,
1753 })
1754 }
1755 }
1756 deserializer.deserialize_struct("hummock.CompactTaskProgress", FIELDS, GeneratedVisitor)
1757 }
1758}
1759impl serde::Serialize for CompactionConfig {
1760 #[allow(deprecated)]
1761 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1762 where
1763 S: serde::Serializer,
1764 {
1765 use serde::ser::SerializeStruct;
1766 let mut len = 0;
1767 if self.max_bytes_for_level_base != 0 {
1768 len += 1;
1769 }
1770 if self.max_level != 0 {
1771 len += 1;
1772 }
1773 if self.max_bytes_for_level_multiplier != 0 {
1774 len += 1;
1775 }
1776 if self.max_compaction_bytes != 0 {
1777 len += 1;
1778 }
1779 if self.sub_level_max_compaction_bytes != 0 {
1780 len += 1;
1781 }
1782 if self.level0_tier_compact_file_number != 0 {
1783 len += 1;
1784 }
1785 if self.compaction_mode != 0 {
1786 len += 1;
1787 }
1788 if !self.compression_algorithm.is_empty() {
1789 len += 1;
1790 }
1791 if self.target_file_size_base != 0 {
1792 len += 1;
1793 }
1794 if self.compaction_filter_mask != 0 {
1795 len += 1;
1796 }
1797 if self.max_sub_compaction != 0 {
1798 len += 1;
1799 }
1800 if self.max_space_reclaim_bytes != 0 {
1801 len += 1;
1802 }
1803 if self.split_by_state_table {
1804 len += 1;
1805 }
1806 if self.split_weight_by_vnode != 0 {
1807 len += 1;
1808 }
1809 if self.level0_stop_write_threshold_sub_level_number != 0 {
1810 len += 1;
1811 }
1812 if self.level0_max_compact_file_number != 0 {
1813 len += 1;
1814 }
1815 if self.level0_sub_level_compact_level_count != 0 {
1816 len += 1;
1817 }
1818 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1819 len += 1;
1820 }
1821 if self.tombstone_reclaim_ratio != 0 {
1822 len += 1;
1823 }
1824 if self.enable_emergency_picker {
1825 len += 1;
1826 }
1827 if self.max_l0_compact_level_count.is_some() {
1828 len += 1;
1829 }
1830 if self.sst_allowed_trivial_move_min_size.is_some() {
1831 len += 1;
1832 }
1833 if self.disable_auto_group_scheduling.is_some() {
1834 len += 1;
1835 }
1836 if self.max_overlapping_level_size.is_some() {
1837 len += 1;
1838 }
1839 if self.emergency_level0_sst_file_count.is_some() {
1840 len += 1;
1841 }
1842 if self.emergency_level0_sub_level_partition.is_some() {
1843 len += 1;
1844 }
1845 if self.level0_stop_write_threshold_max_sst_count.is_some() {
1846 len += 1;
1847 }
1848 if self.level0_stop_write_threshold_max_size.is_some() {
1849 len += 1;
1850 }
1851 if self.sst_allowed_trivial_move_max_count.is_some() {
1852 len += 1;
1853 }
1854 if self.enable_optimize_l0_interval_selection.is_some() {
1855 len += 1;
1856 }
1857 let mut struct_ser = serializer.serialize_struct("hummock.CompactionConfig", len)?;
1858 if self.max_bytes_for_level_base != 0 {
1859 #[allow(clippy::needless_borrow)]
1860 #[allow(clippy::needless_borrows_for_generic_args)]
1861 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&self.max_bytes_for_level_base).as_str())?;
1862 }
1863 if self.max_level != 0 {
1864 #[allow(clippy::needless_borrow)]
1865 #[allow(clippy::needless_borrows_for_generic_args)]
1866 struct_ser.serialize_field("maxLevel", ToString::to_string(&self.max_level).as_str())?;
1867 }
1868 if self.max_bytes_for_level_multiplier != 0 {
1869 #[allow(clippy::needless_borrow)]
1870 #[allow(clippy::needless_borrows_for_generic_args)]
1871 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&self.max_bytes_for_level_multiplier).as_str())?;
1872 }
1873 if self.max_compaction_bytes != 0 {
1874 #[allow(clippy::needless_borrow)]
1875 #[allow(clippy::needless_borrows_for_generic_args)]
1876 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&self.max_compaction_bytes).as_str())?;
1877 }
1878 if self.sub_level_max_compaction_bytes != 0 {
1879 #[allow(clippy::needless_borrow)]
1880 #[allow(clippy::needless_borrows_for_generic_args)]
1881 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&self.sub_level_max_compaction_bytes).as_str())?;
1882 }
1883 if self.level0_tier_compact_file_number != 0 {
1884 #[allow(clippy::needless_borrow)]
1885 #[allow(clippy::needless_borrows_for_generic_args)]
1886 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&self.level0_tier_compact_file_number).as_str())?;
1887 }
1888 if self.compaction_mode != 0 {
1889 let v = compaction_config::CompactionMode::try_from(self.compaction_mode)
1890 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compaction_mode)))?;
1891 struct_ser.serialize_field("compactionMode", &v)?;
1892 }
1893 if !self.compression_algorithm.is_empty() {
1894 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
1895 }
1896 if self.target_file_size_base != 0 {
1897 #[allow(clippy::needless_borrow)]
1898 #[allow(clippy::needless_borrows_for_generic_args)]
1899 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&self.target_file_size_base).as_str())?;
1900 }
1901 if self.compaction_filter_mask != 0 {
1902 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
1903 }
1904 if self.max_sub_compaction != 0 {
1905 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
1906 }
1907 if self.max_space_reclaim_bytes != 0 {
1908 #[allow(clippy::needless_borrow)]
1909 #[allow(clippy::needless_borrows_for_generic_args)]
1910 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&self.max_space_reclaim_bytes).as_str())?;
1911 }
1912 if self.split_by_state_table {
1913 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
1914 }
1915 if self.split_weight_by_vnode != 0 {
1916 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
1917 }
1918 if self.level0_stop_write_threshold_sub_level_number != 0 {
1919 #[allow(clippy::needless_borrow)]
1920 #[allow(clippy::needless_borrows_for_generic_args)]
1921 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&self.level0_stop_write_threshold_sub_level_number).as_str())?;
1922 }
1923 if self.level0_max_compact_file_number != 0 {
1924 #[allow(clippy::needless_borrow)]
1925 #[allow(clippy::needless_borrows_for_generic_args)]
1926 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&self.level0_max_compact_file_number).as_str())?;
1927 }
1928 if self.level0_sub_level_compact_level_count != 0 {
1929 struct_ser.serialize_field("level0SubLevelCompactLevelCount", &self.level0_sub_level_compact_level_count)?;
1930 }
1931 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1932 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", &self.level0_overlapping_sub_level_compact_level_count)?;
1933 }
1934 if self.tombstone_reclaim_ratio != 0 {
1935 struct_ser.serialize_field("tombstoneReclaimRatio", &self.tombstone_reclaim_ratio)?;
1936 }
1937 if self.enable_emergency_picker {
1938 struct_ser.serialize_field("enableEmergencyPicker", &self.enable_emergency_picker)?;
1939 }
1940 if let Some(v) = self.max_l0_compact_level_count.as_ref() {
1941 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
1942 }
1943 if let Some(v) = self.sst_allowed_trivial_move_min_size.as_ref() {
1944 #[allow(clippy::needless_borrow)]
1945 #[allow(clippy::needless_borrows_for_generic_args)]
1946 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
1947 }
1948 if let Some(v) = self.disable_auto_group_scheduling.as_ref() {
1949 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
1950 }
1951 if let Some(v) = self.max_overlapping_level_size.as_ref() {
1952 #[allow(clippy::needless_borrow)]
1953 #[allow(clippy::needless_borrows_for_generic_args)]
1954 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
1955 }
1956 if let Some(v) = self.emergency_level0_sst_file_count.as_ref() {
1957 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
1958 }
1959 if let Some(v) = self.emergency_level0_sub_level_partition.as_ref() {
1960 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
1961 }
1962 if let Some(v) = self.level0_stop_write_threshold_max_sst_count.as_ref() {
1963 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
1964 }
1965 if let Some(v) = self.level0_stop_write_threshold_max_size.as_ref() {
1966 #[allow(clippy::needless_borrow)]
1967 #[allow(clippy::needless_borrows_for_generic_args)]
1968 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
1969 }
1970 if let Some(v) = self.sst_allowed_trivial_move_max_count.as_ref() {
1971 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
1972 }
1973 if let Some(v) = self.enable_optimize_l0_interval_selection.as_ref() {
1974 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
1975 }
1976 struct_ser.end()
1977 }
1978}
1979impl<'de> serde::Deserialize<'de> for CompactionConfig {
1980 #[allow(deprecated)]
1981 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1982 where
1983 D: serde::Deserializer<'de>,
1984 {
1985 const FIELDS: &[&str] = &[
1986 "max_bytes_for_level_base",
1987 "maxBytesForLevelBase",
1988 "max_level",
1989 "maxLevel",
1990 "max_bytes_for_level_multiplier",
1991 "maxBytesForLevelMultiplier",
1992 "max_compaction_bytes",
1993 "maxCompactionBytes",
1994 "sub_level_max_compaction_bytes",
1995 "subLevelMaxCompactionBytes",
1996 "level0_tier_compact_file_number",
1997 "level0TierCompactFileNumber",
1998 "compaction_mode",
1999 "compactionMode",
2000 "compression_algorithm",
2001 "compressionAlgorithm",
2002 "target_file_size_base",
2003 "targetFileSizeBase",
2004 "compaction_filter_mask",
2005 "compactionFilterMask",
2006 "max_sub_compaction",
2007 "maxSubCompaction",
2008 "max_space_reclaim_bytes",
2009 "maxSpaceReclaimBytes",
2010 "split_by_state_table",
2011 "splitByStateTable",
2012 "split_weight_by_vnode",
2013 "splitWeightByVnode",
2014 "level0_stop_write_threshold_sub_level_number",
2015 "level0StopWriteThresholdSubLevelNumber",
2016 "level0_max_compact_file_number",
2017 "level0MaxCompactFileNumber",
2018 "level0_sub_level_compact_level_count",
2019 "level0SubLevelCompactLevelCount",
2020 "level0_overlapping_sub_level_compact_level_count",
2021 "level0OverlappingSubLevelCompactLevelCount",
2022 "tombstone_reclaim_ratio",
2023 "tombstoneReclaimRatio",
2024 "enable_emergency_picker",
2025 "enableEmergencyPicker",
2026 "max_l0_compact_level_count",
2027 "maxL0CompactLevelCount",
2028 "sst_allowed_trivial_move_min_size",
2029 "sstAllowedTrivialMoveMinSize",
2030 "disable_auto_group_scheduling",
2031 "disableAutoGroupScheduling",
2032 "max_overlapping_level_size",
2033 "maxOverlappingLevelSize",
2034 "emergency_level0_sst_file_count",
2035 "emergencyLevel0SstFileCount",
2036 "emergency_level0_sub_level_partition",
2037 "emergencyLevel0SubLevelPartition",
2038 "level0_stop_write_threshold_max_sst_count",
2039 "level0StopWriteThresholdMaxSstCount",
2040 "level0_stop_write_threshold_max_size",
2041 "level0StopWriteThresholdMaxSize",
2042 "sst_allowed_trivial_move_max_count",
2043 "sstAllowedTrivialMoveMaxCount",
2044 "enable_optimize_l0_interval_selection",
2045 "enableOptimizeL0IntervalSelection",
2046 ];
2047
2048 #[allow(clippy::enum_variant_names)]
2049 enum GeneratedField {
2050 MaxBytesForLevelBase,
2051 MaxLevel,
2052 MaxBytesForLevelMultiplier,
2053 MaxCompactionBytes,
2054 SubLevelMaxCompactionBytes,
2055 Level0TierCompactFileNumber,
2056 CompactionMode,
2057 CompressionAlgorithm,
2058 TargetFileSizeBase,
2059 CompactionFilterMask,
2060 MaxSubCompaction,
2061 MaxSpaceReclaimBytes,
2062 SplitByStateTable,
2063 SplitWeightByVnode,
2064 Level0StopWriteThresholdSubLevelNumber,
2065 Level0MaxCompactFileNumber,
2066 Level0SubLevelCompactLevelCount,
2067 Level0OverlappingSubLevelCompactLevelCount,
2068 TombstoneReclaimRatio,
2069 EnableEmergencyPicker,
2070 MaxL0CompactLevelCount,
2071 SstAllowedTrivialMoveMinSize,
2072 DisableAutoGroupScheduling,
2073 MaxOverlappingLevelSize,
2074 EmergencyLevel0SstFileCount,
2075 EmergencyLevel0SubLevelPartition,
2076 Level0StopWriteThresholdMaxSstCount,
2077 Level0StopWriteThresholdMaxSize,
2078 SstAllowedTrivialMoveMaxCount,
2079 EnableOptimizeL0IntervalSelection,
2080 }
2081 impl<'de> serde::Deserialize<'de> for GeneratedField {
2082 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2083 where
2084 D: serde::Deserializer<'de>,
2085 {
2086 struct GeneratedVisitor;
2087
2088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2089 type Value = GeneratedField;
2090
2091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2092 write!(formatter, "expected one of: {:?}", &FIELDS)
2093 }
2094
2095 #[allow(unused_variables)]
2096 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2097 where
2098 E: serde::de::Error,
2099 {
2100 match value {
2101 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
2102 "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2103 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
2104 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
2105 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
2106 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
2107 "compactionMode" | "compaction_mode" => Ok(GeneratedField::CompactionMode),
2108 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
2109 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
2110 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
2111 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
2112 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
2113 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
2114 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
2115 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
2116 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
2117 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
2118 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
2119 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
2120 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
2121 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
2122 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
2123 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
2124 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
2125 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
2126 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
2127 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
2128 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
2129 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
2130 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
2131 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2132 }
2133 }
2134 }
2135 deserializer.deserialize_identifier(GeneratedVisitor)
2136 }
2137 }
2138 struct GeneratedVisitor;
2139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2140 type Value = CompactionConfig;
2141
2142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2143 formatter.write_str("struct hummock.CompactionConfig")
2144 }
2145
2146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionConfig, V::Error>
2147 where
2148 V: serde::de::MapAccess<'de>,
2149 {
2150 let mut max_bytes_for_level_base__ = None;
2151 let mut max_level__ = None;
2152 let mut max_bytes_for_level_multiplier__ = None;
2153 let mut max_compaction_bytes__ = None;
2154 let mut sub_level_max_compaction_bytes__ = None;
2155 let mut level0_tier_compact_file_number__ = None;
2156 let mut compaction_mode__ = None;
2157 let mut compression_algorithm__ = None;
2158 let mut target_file_size_base__ = None;
2159 let mut compaction_filter_mask__ = None;
2160 let mut max_sub_compaction__ = None;
2161 let mut max_space_reclaim_bytes__ = None;
2162 let mut split_by_state_table__ = None;
2163 let mut split_weight_by_vnode__ = None;
2164 let mut level0_stop_write_threshold_sub_level_number__ = None;
2165 let mut level0_max_compact_file_number__ = None;
2166 let mut level0_sub_level_compact_level_count__ = None;
2167 let mut level0_overlapping_sub_level_compact_level_count__ = None;
2168 let mut tombstone_reclaim_ratio__ = None;
2169 let mut enable_emergency_picker__ = None;
2170 let mut max_l0_compact_level_count__ = None;
2171 let mut sst_allowed_trivial_move_min_size__ = None;
2172 let mut disable_auto_group_scheduling__ = None;
2173 let mut max_overlapping_level_size__ = None;
2174 let mut emergency_level0_sst_file_count__ = None;
2175 let mut emergency_level0_sub_level_partition__ = None;
2176 let mut level0_stop_write_threshold_max_sst_count__ = None;
2177 let mut level0_stop_write_threshold_max_size__ = None;
2178 let mut sst_allowed_trivial_move_max_count__ = None;
2179 let mut enable_optimize_l0_interval_selection__ = None;
2180 while let Some(k) = map_.next_key()? {
2181 match k {
2182 GeneratedField::MaxBytesForLevelBase => {
2183 if max_bytes_for_level_base__.is_some() {
2184 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
2185 }
2186 max_bytes_for_level_base__ =
2187 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2188 ;
2189 }
2190 GeneratedField::MaxLevel => {
2191 if max_level__.is_some() {
2192 return Err(serde::de::Error::duplicate_field("maxLevel"));
2193 }
2194 max_level__ =
2195 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2196 ;
2197 }
2198 GeneratedField::MaxBytesForLevelMultiplier => {
2199 if max_bytes_for_level_multiplier__.is_some() {
2200 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
2201 }
2202 max_bytes_for_level_multiplier__ =
2203 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2204 ;
2205 }
2206 GeneratedField::MaxCompactionBytes => {
2207 if max_compaction_bytes__.is_some() {
2208 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
2209 }
2210 max_compaction_bytes__ =
2211 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2212 ;
2213 }
2214 GeneratedField::SubLevelMaxCompactionBytes => {
2215 if sub_level_max_compaction_bytes__.is_some() {
2216 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
2217 }
2218 sub_level_max_compaction_bytes__ =
2219 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2220 ;
2221 }
2222 GeneratedField::Level0TierCompactFileNumber => {
2223 if level0_tier_compact_file_number__.is_some() {
2224 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
2225 }
2226 level0_tier_compact_file_number__ =
2227 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2228 ;
2229 }
2230 GeneratedField::CompactionMode => {
2231 if compaction_mode__.is_some() {
2232 return Err(serde::de::Error::duplicate_field("compactionMode"));
2233 }
2234 compaction_mode__ = Some(map_.next_value::<compaction_config::CompactionMode>()? as i32);
2235 }
2236 GeneratedField::CompressionAlgorithm => {
2237 if compression_algorithm__.is_some() {
2238 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
2239 }
2240 compression_algorithm__ = Some(map_.next_value()?);
2241 }
2242 GeneratedField::TargetFileSizeBase => {
2243 if target_file_size_base__.is_some() {
2244 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
2245 }
2246 target_file_size_base__ =
2247 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2248 ;
2249 }
2250 GeneratedField::CompactionFilterMask => {
2251 if compaction_filter_mask__.is_some() {
2252 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
2253 }
2254 compaction_filter_mask__ =
2255 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2256 ;
2257 }
2258 GeneratedField::MaxSubCompaction => {
2259 if max_sub_compaction__.is_some() {
2260 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
2261 }
2262 max_sub_compaction__ =
2263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2264 ;
2265 }
2266 GeneratedField::MaxSpaceReclaimBytes => {
2267 if max_space_reclaim_bytes__.is_some() {
2268 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
2269 }
2270 max_space_reclaim_bytes__ =
2271 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2272 ;
2273 }
2274 GeneratedField::SplitByStateTable => {
2275 if split_by_state_table__.is_some() {
2276 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
2277 }
2278 split_by_state_table__ = Some(map_.next_value()?);
2279 }
2280 GeneratedField::SplitWeightByVnode => {
2281 if split_weight_by_vnode__.is_some() {
2282 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
2283 }
2284 split_weight_by_vnode__ =
2285 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2286 ;
2287 }
2288 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
2289 if level0_stop_write_threshold_sub_level_number__.is_some() {
2290 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
2291 }
2292 level0_stop_write_threshold_sub_level_number__ =
2293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2294 ;
2295 }
2296 GeneratedField::Level0MaxCompactFileNumber => {
2297 if level0_max_compact_file_number__.is_some() {
2298 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
2299 }
2300 level0_max_compact_file_number__ =
2301 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2302 ;
2303 }
2304 GeneratedField::Level0SubLevelCompactLevelCount => {
2305 if level0_sub_level_compact_level_count__.is_some() {
2306 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
2307 }
2308 level0_sub_level_compact_level_count__ =
2309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2310 ;
2311 }
2312 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
2313 if level0_overlapping_sub_level_compact_level_count__.is_some() {
2314 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
2315 }
2316 level0_overlapping_sub_level_compact_level_count__ =
2317 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2318 ;
2319 }
2320 GeneratedField::TombstoneReclaimRatio => {
2321 if tombstone_reclaim_ratio__.is_some() {
2322 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
2323 }
2324 tombstone_reclaim_ratio__ =
2325 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2326 ;
2327 }
2328 GeneratedField::EnableEmergencyPicker => {
2329 if enable_emergency_picker__.is_some() {
2330 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
2331 }
2332 enable_emergency_picker__ = Some(map_.next_value()?);
2333 }
2334 GeneratedField::MaxL0CompactLevelCount => {
2335 if max_l0_compact_level_count__.is_some() {
2336 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
2337 }
2338 max_l0_compact_level_count__ =
2339 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2340 ;
2341 }
2342 GeneratedField::SstAllowedTrivialMoveMinSize => {
2343 if sst_allowed_trivial_move_min_size__.is_some() {
2344 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
2345 }
2346 sst_allowed_trivial_move_min_size__ =
2347 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2348 ;
2349 }
2350 GeneratedField::DisableAutoGroupScheduling => {
2351 if disable_auto_group_scheduling__.is_some() {
2352 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
2353 }
2354 disable_auto_group_scheduling__ = map_.next_value()?;
2355 }
2356 GeneratedField::MaxOverlappingLevelSize => {
2357 if max_overlapping_level_size__.is_some() {
2358 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
2359 }
2360 max_overlapping_level_size__ =
2361 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2362 ;
2363 }
2364 GeneratedField::EmergencyLevel0SstFileCount => {
2365 if emergency_level0_sst_file_count__.is_some() {
2366 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
2367 }
2368 emergency_level0_sst_file_count__ =
2369 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2370 ;
2371 }
2372 GeneratedField::EmergencyLevel0SubLevelPartition => {
2373 if emergency_level0_sub_level_partition__.is_some() {
2374 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
2375 }
2376 emergency_level0_sub_level_partition__ =
2377 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2378 ;
2379 }
2380 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
2381 if level0_stop_write_threshold_max_sst_count__.is_some() {
2382 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
2383 }
2384 level0_stop_write_threshold_max_sst_count__ =
2385 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2386 ;
2387 }
2388 GeneratedField::Level0StopWriteThresholdMaxSize => {
2389 if level0_stop_write_threshold_max_size__.is_some() {
2390 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
2391 }
2392 level0_stop_write_threshold_max_size__ =
2393 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2394 ;
2395 }
2396 GeneratedField::SstAllowedTrivialMoveMaxCount => {
2397 if sst_allowed_trivial_move_max_count__.is_some() {
2398 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
2399 }
2400 sst_allowed_trivial_move_max_count__ =
2401 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2402 ;
2403 }
2404 GeneratedField::EnableOptimizeL0IntervalSelection => {
2405 if enable_optimize_l0_interval_selection__.is_some() {
2406 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
2407 }
2408 enable_optimize_l0_interval_selection__ = map_.next_value()?;
2409 }
2410 }
2411 }
2412 Ok(CompactionConfig {
2413 max_bytes_for_level_base: max_bytes_for_level_base__.unwrap_or_default(),
2414 max_level: max_level__.unwrap_or_default(),
2415 max_bytes_for_level_multiplier: max_bytes_for_level_multiplier__.unwrap_or_default(),
2416 max_compaction_bytes: max_compaction_bytes__.unwrap_or_default(),
2417 sub_level_max_compaction_bytes: sub_level_max_compaction_bytes__.unwrap_or_default(),
2418 level0_tier_compact_file_number: level0_tier_compact_file_number__.unwrap_or_default(),
2419 compaction_mode: compaction_mode__.unwrap_or_default(),
2420 compression_algorithm: compression_algorithm__.unwrap_or_default(),
2421 target_file_size_base: target_file_size_base__.unwrap_or_default(),
2422 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
2423 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
2424 max_space_reclaim_bytes: max_space_reclaim_bytes__.unwrap_or_default(),
2425 split_by_state_table: split_by_state_table__.unwrap_or_default(),
2426 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
2427 level0_stop_write_threshold_sub_level_number: level0_stop_write_threshold_sub_level_number__.unwrap_or_default(),
2428 level0_max_compact_file_number: level0_max_compact_file_number__.unwrap_or_default(),
2429 level0_sub_level_compact_level_count: level0_sub_level_compact_level_count__.unwrap_or_default(),
2430 level0_overlapping_sub_level_compact_level_count: level0_overlapping_sub_level_compact_level_count__.unwrap_or_default(),
2431 tombstone_reclaim_ratio: tombstone_reclaim_ratio__.unwrap_or_default(),
2432 enable_emergency_picker: enable_emergency_picker__.unwrap_or_default(),
2433 max_l0_compact_level_count: max_l0_compact_level_count__,
2434 sst_allowed_trivial_move_min_size: sst_allowed_trivial_move_min_size__,
2435 disable_auto_group_scheduling: disable_auto_group_scheduling__,
2436 max_overlapping_level_size: max_overlapping_level_size__,
2437 emergency_level0_sst_file_count: emergency_level0_sst_file_count__,
2438 emergency_level0_sub_level_partition: emergency_level0_sub_level_partition__,
2439 level0_stop_write_threshold_max_sst_count: level0_stop_write_threshold_max_sst_count__,
2440 level0_stop_write_threshold_max_size: level0_stop_write_threshold_max_size__,
2441 sst_allowed_trivial_move_max_count: sst_allowed_trivial_move_max_count__,
2442 enable_optimize_l0_interval_selection: enable_optimize_l0_interval_selection__,
2443 })
2444 }
2445 }
2446 deserializer.deserialize_struct("hummock.CompactionConfig", FIELDS, GeneratedVisitor)
2447 }
2448}
2449impl serde::Serialize for compaction_config::CompactionMode {
2450 #[allow(deprecated)]
2451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2452 where
2453 S: serde::Serializer,
2454 {
2455 let variant = match self {
2456 Self::Unspecified => "UNSPECIFIED",
2457 Self::Range => "RANGE",
2458 };
2459 serializer.serialize_str(variant)
2460 }
2461}
2462impl<'de> serde::Deserialize<'de> for compaction_config::CompactionMode {
2463 #[allow(deprecated)]
2464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2465 where
2466 D: serde::Deserializer<'de>,
2467 {
2468 const FIELDS: &[&str] = &[
2469 "UNSPECIFIED",
2470 "RANGE",
2471 ];
2472
2473 struct GeneratedVisitor;
2474
2475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2476 type Value = compaction_config::CompactionMode;
2477
2478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2479 write!(formatter, "expected one of: {:?}", &FIELDS)
2480 }
2481
2482 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2483 where
2484 E: serde::de::Error,
2485 {
2486 i32::try_from(v)
2487 .ok()
2488 .and_then(|x| x.try_into().ok())
2489 .ok_or_else(|| {
2490 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2491 })
2492 }
2493
2494 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2495 where
2496 E: serde::de::Error,
2497 {
2498 i32::try_from(v)
2499 .ok()
2500 .and_then(|x| x.try_into().ok())
2501 .ok_or_else(|| {
2502 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2503 })
2504 }
2505
2506 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2507 where
2508 E: serde::de::Error,
2509 {
2510 match value {
2511 "UNSPECIFIED" => Ok(compaction_config::CompactionMode::Unspecified),
2512 "RANGE" => Ok(compaction_config::CompactionMode::Range),
2513 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2514 }
2515 }
2516 }
2517 deserializer.deserialize_any(GeneratedVisitor)
2518 }
2519}
2520impl serde::Serialize for CompactionGroup {
2521 #[allow(deprecated)]
2522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2523 where
2524 S: serde::Serializer,
2525 {
2526 use serde::ser::SerializeStruct;
2527 let mut len = 0;
2528 if self.id != 0 {
2529 len += 1;
2530 }
2531 if self.compaction_config.is_some() {
2532 len += 1;
2533 }
2534 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroup", len)?;
2535 if self.id != 0 {
2536 #[allow(clippy::needless_borrow)]
2537 #[allow(clippy::needless_borrows_for_generic_args)]
2538 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2539 }
2540 if let Some(v) = self.compaction_config.as_ref() {
2541 struct_ser.serialize_field("compactionConfig", v)?;
2542 }
2543 struct_ser.end()
2544 }
2545}
2546impl<'de> serde::Deserialize<'de> for CompactionGroup {
2547 #[allow(deprecated)]
2548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2549 where
2550 D: serde::Deserializer<'de>,
2551 {
2552 const FIELDS: &[&str] = &[
2553 "id",
2554 "compaction_config",
2555 "compactionConfig",
2556 ];
2557
2558 #[allow(clippy::enum_variant_names)]
2559 enum GeneratedField {
2560 Id,
2561 CompactionConfig,
2562 }
2563 impl<'de> serde::Deserialize<'de> for GeneratedField {
2564 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2565 where
2566 D: serde::Deserializer<'de>,
2567 {
2568 struct GeneratedVisitor;
2569
2570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2571 type Value = GeneratedField;
2572
2573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2574 write!(formatter, "expected one of: {:?}", &FIELDS)
2575 }
2576
2577 #[allow(unused_variables)]
2578 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2579 where
2580 E: serde::de::Error,
2581 {
2582 match value {
2583 "id" => Ok(GeneratedField::Id),
2584 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2585 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2586 }
2587 }
2588 }
2589 deserializer.deserialize_identifier(GeneratedVisitor)
2590 }
2591 }
2592 struct GeneratedVisitor;
2593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2594 type Value = CompactionGroup;
2595
2596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2597 formatter.write_str("struct hummock.CompactionGroup")
2598 }
2599
2600 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroup, V::Error>
2601 where
2602 V: serde::de::MapAccess<'de>,
2603 {
2604 let mut id__ = None;
2605 let mut compaction_config__ = None;
2606 while let Some(k) = map_.next_key()? {
2607 match k {
2608 GeneratedField::Id => {
2609 if id__.is_some() {
2610 return Err(serde::de::Error::duplicate_field("id"));
2611 }
2612 id__ =
2613 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2614 ;
2615 }
2616 GeneratedField::CompactionConfig => {
2617 if compaction_config__.is_some() {
2618 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2619 }
2620 compaction_config__ = map_.next_value()?;
2621 }
2622 }
2623 }
2624 Ok(CompactionGroup {
2625 id: id__.unwrap_or_default(),
2626 compaction_config: compaction_config__,
2627 })
2628 }
2629 }
2630 deserializer.deserialize_struct("hummock.CompactionGroup", FIELDS, GeneratedVisitor)
2631 }
2632}
2633impl serde::Serialize for CompactionGroupInfo {
2634 #[allow(deprecated)]
2635 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2636 where
2637 S: serde::Serializer,
2638 {
2639 use serde::ser::SerializeStruct;
2640 let mut len = 0;
2641 if self.id != 0 {
2642 len += 1;
2643 }
2644 if self.parent_id != 0 {
2645 len += 1;
2646 }
2647 if !self.member_table_ids.is_empty() {
2648 len += 1;
2649 }
2650 if self.compaction_config.is_some() {
2651 len += 1;
2652 }
2653 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroupInfo", len)?;
2654 if self.id != 0 {
2655 #[allow(clippy::needless_borrow)]
2656 #[allow(clippy::needless_borrows_for_generic_args)]
2657 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2658 }
2659 if self.parent_id != 0 {
2660 #[allow(clippy::needless_borrow)]
2661 #[allow(clippy::needless_borrows_for_generic_args)]
2662 struct_ser.serialize_field("parentId", ToString::to_string(&self.parent_id).as_str())?;
2663 }
2664 if !self.member_table_ids.is_empty() {
2665 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
2666 }
2667 if let Some(v) = self.compaction_config.as_ref() {
2668 struct_ser.serialize_field("compactionConfig", v)?;
2669 }
2670 struct_ser.end()
2671 }
2672}
2673impl<'de> serde::Deserialize<'de> for CompactionGroupInfo {
2674 #[allow(deprecated)]
2675 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2676 where
2677 D: serde::Deserializer<'de>,
2678 {
2679 const FIELDS: &[&str] = &[
2680 "id",
2681 "parent_id",
2682 "parentId",
2683 "member_table_ids",
2684 "memberTableIds",
2685 "compaction_config",
2686 "compactionConfig",
2687 ];
2688
2689 #[allow(clippy::enum_variant_names)]
2690 enum GeneratedField {
2691 Id,
2692 ParentId,
2693 MemberTableIds,
2694 CompactionConfig,
2695 }
2696 impl<'de> serde::Deserialize<'de> for GeneratedField {
2697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2698 where
2699 D: serde::Deserializer<'de>,
2700 {
2701 struct GeneratedVisitor;
2702
2703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2704 type Value = GeneratedField;
2705
2706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2707 write!(formatter, "expected one of: {:?}", &FIELDS)
2708 }
2709
2710 #[allow(unused_variables)]
2711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2712 where
2713 E: serde::de::Error,
2714 {
2715 match value {
2716 "id" => Ok(GeneratedField::Id),
2717 "parentId" | "parent_id" => Ok(GeneratedField::ParentId),
2718 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
2719 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2721 }
2722 }
2723 }
2724 deserializer.deserialize_identifier(GeneratedVisitor)
2725 }
2726 }
2727 struct GeneratedVisitor;
2728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2729 type Value = CompactionGroupInfo;
2730
2731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2732 formatter.write_str("struct hummock.CompactionGroupInfo")
2733 }
2734
2735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroupInfo, V::Error>
2736 where
2737 V: serde::de::MapAccess<'de>,
2738 {
2739 let mut id__ = None;
2740 let mut parent_id__ = None;
2741 let mut member_table_ids__ = None;
2742 let mut compaction_config__ = None;
2743 while let Some(k) = map_.next_key()? {
2744 match k {
2745 GeneratedField::Id => {
2746 if id__.is_some() {
2747 return Err(serde::de::Error::duplicate_field("id"));
2748 }
2749 id__ =
2750 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2751 ;
2752 }
2753 GeneratedField::ParentId => {
2754 if parent_id__.is_some() {
2755 return Err(serde::de::Error::duplicate_field("parentId"));
2756 }
2757 parent_id__ =
2758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2759 ;
2760 }
2761 GeneratedField::MemberTableIds => {
2762 if member_table_ids__.is_some() {
2763 return Err(serde::de::Error::duplicate_field("memberTableIds"));
2764 }
2765 member_table_ids__ =
2766 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2767 .into_iter().map(|x| x.0).collect())
2768 ;
2769 }
2770 GeneratedField::CompactionConfig => {
2771 if compaction_config__.is_some() {
2772 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2773 }
2774 compaction_config__ = map_.next_value()?;
2775 }
2776 }
2777 }
2778 Ok(CompactionGroupInfo {
2779 id: id__.unwrap_or_default(),
2780 parent_id: parent_id__.unwrap_or_default(),
2781 member_table_ids: member_table_ids__.unwrap_or_default(),
2782 compaction_config: compaction_config__,
2783 })
2784 }
2785 }
2786 deserializer.deserialize_struct("hummock.CompactionGroupInfo", FIELDS, GeneratedVisitor)
2787 }
2788}
2789impl serde::Serialize for CompatibilityVersion {
2790 #[allow(deprecated)]
2791 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2792 where
2793 S: serde::Serializer,
2794 {
2795 let variant = match self {
2796 Self::VersionUnspecified => "VERSION_UNSPECIFIED",
2797 Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
2798 Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
2799 Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
2800 };
2801 serializer.serialize_str(variant)
2802 }
2803}
2804impl<'de> serde::Deserialize<'de> for CompatibilityVersion {
2805 #[allow(deprecated)]
2806 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2807 where
2808 D: serde::Deserializer<'de>,
2809 {
2810 const FIELDS: &[&str] = &[
2811 "VERSION_UNSPECIFIED",
2812 "NO_TRIVIAL_SPLIT",
2813 "NO_MEMBER_TABLE_IDS",
2814 "SPLIT_GROUP_BY_TABLE_ID",
2815 ];
2816
2817 struct GeneratedVisitor;
2818
2819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2820 type Value = CompatibilityVersion;
2821
2822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2823 write!(formatter, "expected one of: {:?}", &FIELDS)
2824 }
2825
2826 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2827 where
2828 E: serde::de::Error,
2829 {
2830 i32::try_from(v)
2831 .ok()
2832 .and_then(|x| x.try_into().ok())
2833 .ok_or_else(|| {
2834 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2835 })
2836 }
2837
2838 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2839 where
2840 E: serde::de::Error,
2841 {
2842 i32::try_from(v)
2843 .ok()
2844 .and_then(|x| x.try_into().ok())
2845 .ok_or_else(|| {
2846 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2847 })
2848 }
2849
2850 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2851 where
2852 E: serde::de::Error,
2853 {
2854 match value {
2855 "VERSION_UNSPECIFIED" => Ok(CompatibilityVersion::VersionUnspecified),
2856 "NO_TRIVIAL_SPLIT" => Ok(CompatibilityVersion::NoTrivialSplit),
2857 "NO_MEMBER_TABLE_IDS" => Ok(CompatibilityVersion::NoMemberTableIds),
2858 "SPLIT_GROUP_BY_TABLE_ID" => Ok(CompatibilityVersion::SplitGroupByTableId),
2859 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2860 }
2861 }
2862 }
2863 deserializer.deserialize_any(GeneratedVisitor)
2864 }
2865}
2866impl serde::Serialize for DisableCommitEpochRequest {
2867 #[allow(deprecated)]
2868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2869 where
2870 S: serde::Serializer,
2871 {
2872 use serde::ser::SerializeStruct;
2873 let len = 0;
2874 let struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochRequest", len)?;
2875 struct_ser.end()
2876 }
2877}
2878impl<'de> serde::Deserialize<'de> for DisableCommitEpochRequest {
2879 #[allow(deprecated)]
2880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2881 where
2882 D: serde::Deserializer<'de>,
2883 {
2884 const FIELDS: &[&str] = &[
2885 ];
2886
2887 #[allow(clippy::enum_variant_names)]
2888 enum GeneratedField {
2889 }
2890 impl<'de> serde::Deserialize<'de> for GeneratedField {
2891 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2892 where
2893 D: serde::Deserializer<'de>,
2894 {
2895 struct GeneratedVisitor;
2896
2897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2898 type Value = GeneratedField;
2899
2900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2901 write!(formatter, "expected one of: {:?}", &FIELDS)
2902 }
2903
2904 #[allow(unused_variables)]
2905 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2906 where
2907 E: serde::de::Error,
2908 {
2909 Err(serde::de::Error::unknown_field(value, FIELDS))
2910 }
2911 }
2912 deserializer.deserialize_identifier(GeneratedVisitor)
2913 }
2914 }
2915 struct GeneratedVisitor;
2916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2917 type Value = DisableCommitEpochRequest;
2918
2919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2920 formatter.write_str("struct hummock.DisableCommitEpochRequest")
2921 }
2922
2923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochRequest, V::Error>
2924 where
2925 V: serde::de::MapAccess<'de>,
2926 {
2927 while map_.next_key::<GeneratedField>()?.is_some() {
2928 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2929 }
2930 Ok(DisableCommitEpochRequest {
2931 })
2932 }
2933 }
2934 deserializer.deserialize_struct("hummock.DisableCommitEpochRequest", FIELDS, GeneratedVisitor)
2935 }
2936}
2937impl serde::Serialize for DisableCommitEpochResponse {
2938 #[allow(deprecated)]
2939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2940 where
2941 S: serde::Serializer,
2942 {
2943 use serde::ser::SerializeStruct;
2944 let mut len = 0;
2945 if self.current_version.is_some() {
2946 len += 1;
2947 }
2948 let mut struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochResponse", len)?;
2949 if let Some(v) = self.current_version.as_ref() {
2950 struct_ser.serialize_field("currentVersion", v)?;
2951 }
2952 struct_ser.end()
2953 }
2954}
2955impl<'de> serde::Deserialize<'de> for DisableCommitEpochResponse {
2956 #[allow(deprecated)]
2957 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2958 where
2959 D: serde::Deserializer<'de>,
2960 {
2961 const FIELDS: &[&str] = &[
2962 "current_version",
2963 "currentVersion",
2964 ];
2965
2966 #[allow(clippy::enum_variant_names)]
2967 enum GeneratedField {
2968 CurrentVersion,
2969 }
2970 impl<'de> serde::Deserialize<'de> for GeneratedField {
2971 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2972 where
2973 D: serde::Deserializer<'de>,
2974 {
2975 struct GeneratedVisitor;
2976
2977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2978 type Value = GeneratedField;
2979
2980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2981 write!(formatter, "expected one of: {:?}", &FIELDS)
2982 }
2983
2984 #[allow(unused_variables)]
2985 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2986 where
2987 E: serde::de::Error,
2988 {
2989 match value {
2990 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
2991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2992 }
2993 }
2994 }
2995 deserializer.deserialize_identifier(GeneratedVisitor)
2996 }
2997 }
2998 struct GeneratedVisitor;
2999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3000 type Value = DisableCommitEpochResponse;
3001
3002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3003 formatter.write_str("struct hummock.DisableCommitEpochResponse")
3004 }
3005
3006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochResponse, V::Error>
3007 where
3008 V: serde::de::MapAccess<'de>,
3009 {
3010 let mut current_version__ = None;
3011 while let Some(k) = map_.next_key()? {
3012 match k {
3013 GeneratedField::CurrentVersion => {
3014 if current_version__.is_some() {
3015 return Err(serde::de::Error::duplicate_field("currentVersion"));
3016 }
3017 current_version__ = map_.next_value()?;
3018 }
3019 }
3020 }
3021 Ok(DisableCommitEpochResponse {
3022 current_version: current_version__,
3023 })
3024 }
3025 }
3026 deserializer.deserialize_struct("hummock.DisableCommitEpochResponse", FIELDS, GeneratedVisitor)
3027 }
3028}
3029impl serde::Serialize for EpochNewChangeLog {
3030 #[allow(deprecated)]
3031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3032 where
3033 S: serde::Serializer,
3034 {
3035 use serde::ser::SerializeStruct;
3036 let mut len = 0;
3037 if !self.old_value.is_empty() {
3038 len += 1;
3039 }
3040 if !self.new_value.is_empty() {
3041 len += 1;
3042 }
3043 if !self.epochs.is_empty() {
3044 len += 1;
3045 }
3046 let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3047 if !self.old_value.is_empty() {
3048 struct_ser.serialize_field("oldValue", &self.old_value)?;
3049 }
3050 if !self.new_value.is_empty() {
3051 struct_ser.serialize_field("newValue", &self.new_value)?;
3052 }
3053 if !self.epochs.is_empty() {
3054 struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3055 }
3056 struct_ser.end()
3057 }
3058}
3059impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3060 #[allow(deprecated)]
3061 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3062 where
3063 D: serde::Deserializer<'de>,
3064 {
3065 const FIELDS: &[&str] = &[
3066 "old_value",
3067 "oldValue",
3068 "new_value",
3069 "newValue",
3070 "epochs",
3071 ];
3072
3073 #[allow(clippy::enum_variant_names)]
3074 enum GeneratedField {
3075 OldValue,
3076 NewValue,
3077 Epochs,
3078 }
3079 impl<'de> serde::Deserialize<'de> for GeneratedField {
3080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3081 where
3082 D: serde::Deserializer<'de>,
3083 {
3084 struct GeneratedVisitor;
3085
3086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3087 type Value = GeneratedField;
3088
3089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3090 write!(formatter, "expected one of: {:?}", &FIELDS)
3091 }
3092
3093 #[allow(unused_variables)]
3094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3095 where
3096 E: serde::de::Error,
3097 {
3098 match value {
3099 "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3100 "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3101 "epochs" => Ok(GeneratedField::Epochs),
3102 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3103 }
3104 }
3105 }
3106 deserializer.deserialize_identifier(GeneratedVisitor)
3107 }
3108 }
3109 struct GeneratedVisitor;
3110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3111 type Value = EpochNewChangeLog;
3112
3113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3114 formatter.write_str("struct hummock.EpochNewChangeLog")
3115 }
3116
3117 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3118 where
3119 V: serde::de::MapAccess<'de>,
3120 {
3121 let mut old_value__ = None;
3122 let mut new_value__ = None;
3123 let mut epochs__ = None;
3124 while let Some(k) = map_.next_key()? {
3125 match k {
3126 GeneratedField::OldValue => {
3127 if old_value__.is_some() {
3128 return Err(serde::de::Error::duplicate_field("oldValue"));
3129 }
3130 old_value__ = Some(map_.next_value()?);
3131 }
3132 GeneratedField::NewValue => {
3133 if new_value__.is_some() {
3134 return Err(serde::de::Error::duplicate_field("newValue"));
3135 }
3136 new_value__ = Some(map_.next_value()?);
3137 }
3138 GeneratedField::Epochs => {
3139 if epochs__.is_some() {
3140 return Err(serde::de::Error::duplicate_field("epochs"));
3141 }
3142 epochs__ =
3143 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3144 .into_iter().map(|x| x.0).collect())
3145 ;
3146 }
3147 }
3148 }
3149 Ok(EpochNewChangeLog {
3150 old_value: old_value__.unwrap_or_default(),
3151 new_value: new_value__.unwrap_or_default(),
3152 epochs: epochs__.unwrap_or_default(),
3153 })
3154 }
3155 }
3156 deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3157 }
3158}
3159impl serde::Serialize for FlatIndex {
3160 #[allow(deprecated)]
3161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3162 where
3163 S: serde::Serializer,
3164 {
3165 use serde::ser::SerializeStruct;
3166 let mut len = 0;
3167 if self.config.is_some() {
3168 len += 1;
3169 }
3170 if !self.vector_files.is_empty() {
3171 len += 1;
3172 }
3173 if self.next_vector_id != 0 {
3174 len += 1;
3175 }
3176 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3177 if let Some(v) = self.config.as_ref() {
3178 struct_ser.serialize_field("config", v)?;
3179 }
3180 if !self.vector_files.is_empty() {
3181 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3182 }
3183 if self.next_vector_id != 0 {
3184 #[allow(clippy::needless_borrow)]
3185 #[allow(clippy::needless_borrows_for_generic_args)]
3186 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3187 }
3188 struct_ser.end()
3189 }
3190}
3191impl<'de> serde::Deserialize<'de> for FlatIndex {
3192 #[allow(deprecated)]
3193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3194 where
3195 D: serde::Deserializer<'de>,
3196 {
3197 const FIELDS: &[&str] = &[
3198 "config",
3199 "vector_files",
3200 "vectorFiles",
3201 "next_vector_id",
3202 "nextVectorId",
3203 ];
3204
3205 #[allow(clippy::enum_variant_names)]
3206 enum GeneratedField {
3207 Config,
3208 VectorFiles,
3209 NextVectorId,
3210 }
3211 impl<'de> serde::Deserialize<'de> for GeneratedField {
3212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3213 where
3214 D: serde::Deserializer<'de>,
3215 {
3216 struct GeneratedVisitor;
3217
3218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3219 type Value = GeneratedField;
3220
3221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3222 write!(formatter, "expected one of: {:?}", &FIELDS)
3223 }
3224
3225 #[allow(unused_variables)]
3226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3227 where
3228 E: serde::de::Error,
3229 {
3230 match value {
3231 "config" => Ok(GeneratedField::Config),
3232 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3233 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3234 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3235 }
3236 }
3237 }
3238 deserializer.deserialize_identifier(GeneratedVisitor)
3239 }
3240 }
3241 struct GeneratedVisitor;
3242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3243 type Value = FlatIndex;
3244
3245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3246 formatter.write_str("struct hummock.FlatIndex")
3247 }
3248
3249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3250 where
3251 V: serde::de::MapAccess<'de>,
3252 {
3253 let mut config__ = None;
3254 let mut vector_files__ = None;
3255 let mut next_vector_id__ = None;
3256 while let Some(k) = map_.next_key()? {
3257 match k {
3258 GeneratedField::Config => {
3259 if config__.is_some() {
3260 return Err(serde::de::Error::duplicate_field("config"));
3261 }
3262 config__ = map_.next_value()?;
3263 }
3264 GeneratedField::VectorFiles => {
3265 if vector_files__.is_some() {
3266 return Err(serde::de::Error::duplicate_field("vectorFiles"));
3267 }
3268 vector_files__ = Some(map_.next_value()?);
3269 }
3270 GeneratedField::NextVectorId => {
3271 if next_vector_id__.is_some() {
3272 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3273 }
3274 next_vector_id__ =
3275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3276 ;
3277 }
3278 }
3279 }
3280 Ok(FlatIndex {
3281 config: config__,
3282 vector_files: vector_files__.unwrap_or_default(),
3283 next_vector_id: next_vector_id__.unwrap_or_default(),
3284 })
3285 }
3286 }
3287 deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3288 }
3289}
3290impl serde::Serialize for FlatIndexAdd {
3291 #[allow(deprecated)]
3292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3293 where
3294 S: serde::Serializer,
3295 {
3296 use serde::ser::SerializeStruct;
3297 let mut len = 0;
3298 if !self.added_vector_files.is_empty() {
3299 len += 1;
3300 }
3301 if self.next_vector_id != 0 {
3302 len += 1;
3303 }
3304 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3305 if !self.added_vector_files.is_empty() {
3306 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3307 }
3308 if self.next_vector_id != 0 {
3309 #[allow(clippy::needless_borrow)]
3310 #[allow(clippy::needless_borrows_for_generic_args)]
3311 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3312 }
3313 struct_ser.end()
3314 }
3315}
3316impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3317 #[allow(deprecated)]
3318 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3319 where
3320 D: serde::Deserializer<'de>,
3321 {
3322 const FIELDS: &[&str] = &[
3323 "added_vector_files",
3324 "addedVectorFiles",
3325 "next_vector_id",
3326 "nextVectorId",
3327 ];
3328
3329 #[allow(clippy::enum_variant_names)]
3330 enum GeneratedField {
3331 AddedVectorFiles,
3332 NextVectorId,
3333 }
3334 impl<'de> serde::Deserialize<'de> for GeneratedField {
3335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3336 where
3337 D: serde::Deserializer<'de>,
3338 {
3339 struct GeneratedVisitor;
3340
3341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3342 type Value = GeneratedField;
3343
3344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3345 write!(formatter, "expected one of: {:?}", &FIELDS)
3346 }
3347
3348 #[allow(unused_variables)]
3349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3350 where
3351 E: serde::de::Error,
3352 {
3353 match value {
3354 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3355 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3356 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3357 }
3358 }
3359 }
3360 deserializer.deserialize_identifier(GeneratedVisitor)
3361 }
3362 }
3363 struct GeneratedVisitor;
3364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3365 type Value = FlatIndexAdd;
3366
3367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3368 formatter.write_str("struct hummock.FlatIndexAdd")
3369 }
3370
3371 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3372 where
3373 V: serde::de::MapAccess<'de>,
3374 {
3375 let mut added_vector_files__ = None;
3376 let mut next_vector_id__ = None;
3377 while let Some(k) = map_.next_key()? {
3378 match k {
3379 GeneratedField::AddedVectorFiles => {
3380 if added_vector_files__.is_some() {
3381 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3382 }
3383 added_vector_files__ = Some(map_.next_value()?);
3384 }
3385 GeneratedField::NextVectorId => {
3386 if next_vector_id__.is_some() {
3387 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3388 }
3389 next_vector_id__ =
3390 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3391 ;
3392 }
3393 }
3394 }
3395 Ok(FlatIndexAdd {
3396 added_vector_files: added_vector_files__.unwrap_or_default(),
3397 next_vector_id: next_vector_id__.unwrap_or_default(),
3398 })
3399 }
3400 }
3401 deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3402 }
3403}
3404impl serde::Serialize for FullScanTask {
3405 #[allow(deprecated)]
3406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3407 where
3408 S: serde::Serializer,
3409 {
3410 use serde::ser::SerializeStruct;
3411 let mut len = 0;
3412 if self.sst_retention_watermark != 0 {
3413 len += 1;
3414 }
3415 if self.prefix.is_some() {
3416 len += 1;
3417 }
3418 if self.start_after.is_some() {
3419 len += 1;
3420 }
3421 if self.limit.is_some() {
3422 len += 1;
3423 }
3424 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3425 if self.sst_retention_watermark != 0 {
3426 #[allow(clippy::needless_borrow)]
3427 #[allow(clippy::needless_borrows_for_generic_args)]
3428 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3429 }
3430 if let Some(v) = self.prefix.as_ref() {
3431 struct_ser.serialize_field("prefix", v)?;
3432 }
3433 if let Some(v) = self.start_after.as_ref() {
3434 struct_ser.serialize_field("startAfter", v)?;
3435 }
3436 if let Some(v) = self.limit.as_ref() {
3437 #[allow(clippy::needless_borrow)]
3438 #[allow(clippy::needless_borrows_for_generic_args)]
3439 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3440 }
3441 struct_ser.end()
3442 }
3443}
3444impl<'de> serde::Deserialize<'de> for FullScanTask {
3445 #[allow(deprecated)]
3446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3447 where
3448 D: serde::Deserializer<'de>,
3449 {
3450 const FIELDS: &[&str] = &[
3451 "sst_retention_watermark",
3452 "sstRetentionWatermark",
3453 "prefix",
3454 "start_after",
3455 "startAfter",
3456 "limit",
3457 ];
3458
3459 #[allow(clippy::enum_variant_names)]
3460 enum GeneratedField {
3461 SstRetentionWatermark,
3462 Prefix,
3463 StartAfter,
3464 Limit,
3465 }
3466 impl<'de> serde::Deserialize<'de> for GeneratedField {
3467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3468 where
3469 D: serde::Deserializer<'de>,
3470 {
3471 struct GeneratedVisitor;
3472
3473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3474 type Value = GeneratedField;
3475
3476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3477 write!(formatter, "expected one of: {:?}", &FIELDS)
3478 }
3479
3480 #[allow(unused_variables)]
3481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3482 where
3483 E: serde::de::Error,
3484 {
3485 match value {
3486 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3487 "prefix" => Ok(GeneratedField::Prefix),
3488 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3489 "limit" => Ok(GeneratedField::Limit),
3490 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3491 }
3492 }
3493 }
3494 deserializer.deserialize_identifier(GeneratedVisitor)
3495 }
3496 }
3497 struct GeneratedVisitor;
3498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3499 type Value = FullScanTask;
3500
3501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3502 formatter.write_str("struct hummock.FullScanTask")
3503 }
3504
3505 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3506 where
3507 V: serde::de::MapAccess<'de>,
3508 {
3509 let mut sst_retention_watermark__ = None;
3510 let mut prefix__ = None;
3511 let mut start_after__ = None;
3512 let mut limit__ = None;
3513 while let Some(k) = map_.next_key()? {
3514 match k {
3515 GeneratedField::SstRetentionWatermark => {
3516 if sst_retention_watermark__.is_some() {
3517 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3518 }
3519 sst_retention_watermark__ =
3520 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3521 ;
3522 }
3523 GeneratedField::Prefix => {
3524 if prefix__.is_some() {
3525 return Err(serde::de::Error::duplicate_field("prefix"));
3526 }
3527 prefix__ = map_.next_value()?;
3528 }
3529 GeneratedField::StartAfter => {
3530 if start_after__.is_some() {
3531 return Err(serde::de::Error::duplicate_field("startAfter"));
3532 }
3533 start_after__ = map_.next_value()?;
3534 }
3535 GeneratedField::Limit => {
3536 if limit__.is_some() {
3537 return Err(serde::de::Error::duplicate_field("limit"));
3538 }
3539 limit__ =
3540 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3541 ;
3542 }
3543 }
3544 }
3545 Ok(FullScanTask {
3546 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3547 prefix: prefix__,
3548 start_after: start_after__,
3549 limit: limit__,
3550 })
3551 }
3552 }
3553 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3554 }
3555}
3556impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3557 #[allow(deprecated)]
3558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3559 where
3560 S: serde::Serializer,
3561 {
3562 use serde::ser::SerializeStruct;
3563 let len = 0;
3564 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3565 struct_ser.end()
3566 }
3567}
3568impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3569 #[allow(deprecated)]
3570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3571 where
3572 D: serde::Deserializer<'de>,
3573 {
3574 const FIELDS: &[&str] = &[
3575 ];
3576
3577 #[allow(clippy::enum_variant_names)]
3578 enum GeneratedField {
3579 }
3580 impl<'de> serde::Deserialize<'de> for GeneratedField {
3581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3582 where
3583 D: serde::Deserializer<'de>,
3584 {
3585 struct GeneratedVisitor;
3586
3587 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3588 type Value = GeneratedField;
3589
3590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3591 write!(formatter, "expected one of: {:?}", &FIELDS)
3592 }
3593
3594 #[allow(unused_variables)]
3595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3596 where
3597 E: serde::de::Error,
3598 {
3599 Err(serde::de::Error::unknown_field(value, FIELDS))
3600 }
3601 }
3602 deserializer.deserialize_identifier(GeneratedVisitor)
3603 }
3604 }
3605 struct GeneratedVisitor;
3606 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3607 type Value = GetAssignedCompactTaskNumRequest;
3608
3609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3610 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3611 }
3612
3613 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3614 where
3615 V: serde::de::MapAccess<'de>,
3616 {
3617 while map_.next_key::<GeneratedField>()?.is_some() {
3618 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3619 }
3620 Ok(GetAssignedCompactTaskNumRequest {
3621 })
3622 }
3623 }
3624 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3625 }
3626}
3627impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3628 #[allow(deprecated)]
3629 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3630 where
3631 S: serde::Serializer,
3632 {
3633 use serde::ser::SerializeStruct;
3634 let mut len = 0;
3635 if self.num_tasks != 0 {
3636 len += 1;
3637 }
3638 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3639 if self.num_tasks != 0 {
3640 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3641 }
3642 struct_ser.end()
3643 }
3644}
3645impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3646 #[allow(deprecated)]
3647 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3648 where
3649 D: serde::Deserializer<'de>,
3650 {
3651 const FIELDS: &[&str] = &[
3652 "num_tasks",
3653 "numTasks",
3654 ];
3655
3656 #[allow(clippy::enum_variant_names)]
3657 enum GeneratedField {
3658 NumTasks,
3659 }
3660 impl<'de> serde::Deserialize<'de> for GeneratedField {
3661 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3662 where
3663 D: serde::Deserializer<'de>,
3664 {
3665 struct GeneratedVisitor;
3666
3667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3668 type Value = GeneratedField;
3669
3670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3671 write!(formatter, "expected one of: {:?}", &FIELDS)
3672 }
3673
3674 #[allow(unused_variables)]
3675 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3676 where
3677 E: serde::de::Error,
3678 {
3679 match value {
3680 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3681 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3682 }
3683 }
3684 }
3685 deserializer.deserialize_identifier(GeneratedVisitor)
3686 }
3687 }
3688 struct GeneratedVisitor;
3689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3690 type Value = GetAssignedCompactTaskNumResponse;
3691
3692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3693 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3694 }
3695
3696 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3697 where
3698 V: serde::de::MapAccess<'de>,
3699 {
3700 let mut num_tasks__ = None;
3701 while let Some(k) = map_.next_key()? {
3702 match k {
3703 GeneratedField::NumTasks => {
3704 if num_tasks__.is_some() {
3705 return Err(serde::de::Error::duplicate_field("numTasks"));
3706 }
3707 num_tasks__ =
3708 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3709 ;
3710 }
3711 }
3712 }
3713 Ok(GetAssignedCompactTaskNumResponse {
3714 num_tasks: num_tasks__.unwrap_or_default(),
3715 })
3716 }
3717 }
3718 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3719 }
3720}
3721impl serde::Serialize for GetCompactionScoreRequest {
3722 #[allow(deprecated)]
3723 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3724 where
3725 S: serde::Serializer,
3726 {
3727 use serde::ser::SerializeStruct;
3728 let mut len = 0;
3729 if self.compaction_group_id != 0 {
3730 len += 1;
3731 }
3732 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3733 if self.compaction_group_id != 0 {
3734 #[allow(clippy::needless_borrow)]
3735 #[allow(clippy::needless_borrows_for_generic_args)]
3736 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3737 }
3738 struct_ser.end()
3739 }
3740}
3741impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3742 #[allow(deprecated)]
3743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3744 where
3745 D: serde::Deserializer<'de>,
3746 {
3747 const FIELDS: &[&str] = &[
3748 "compaction_group_id",
3749 "compactionGroupId",
3750 ];
3751
3752 #[allow(clippy::enum_variant_names)]
3753 enum GeneratedField {
3754 CompactionGroupId,
3755 }
3756 impl<'de> serde::Deserialize<'de> for GeneratedField {
3757 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3758 where
3759 D: serde::Deserializer<'de>,
3760 {
3761 struct GeneratedVisitor;
3762
3763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3764 type Value = GeneratedField;
3765
3766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3767 write!(formatter, "expected one of: {:?}", &FIELDS)
3768 }
3769
3770 #[allow(unused_variables)]
3771 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3772 where
3773 E: serde::de::Error,
3774 {
3775 match value {
3776 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3778 }
3779 }
3780 }
3781 deserializer.deserialize_identifier(GeneratedVisitor)
3782 }
3783 }
3784 struct GeneratedVisitor;
3785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3786 type Value = GetCompactionScoreRequest;
3787
3788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3789 formatter.write_str("struct hummock.GetCompactionScoreRequest")
3790 }
3791
3792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3793 where
3794 V: serde::de::MapAccess<'de>,
3795 {
3796 let mut compaction_group_id__ = None;
3797 while let Some(k) = map_.next_key()? {
3798 match k {
3799 GeneratedField::CompactionGroupId => {
3800 if compaction_group_id__.is_some() {
3801 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3802 }
3803 compaction_group_id__ =
3804 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3805 ;
3806 }
3807 }
3808 }
3809 Ok(GetCompactionScoreRequest {
3810 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3811 })
3812 }
3813 }
3814 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
3815 }
3816}
3817impl serde::Serialize for GetCompactionScoreResponse {
3818 #[allow(deprecated)]
3819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3820 where
3821 S: serde::Serializer,
3822 {
3823 use serde::ser::SerializeStruct;
3824 let mut len = 0;
3825 if self.compaction_group_id != 0 {
3826 len += 1;
3827 }
3828 if !self.scores.is_empty() {
3829 len += 1;
3830 }
3831 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
3832 if self.compaction_group_id != 0 {
3833 #[allow(clippy::needless_borrow)]
3834 #[allow(clippy::needless_borrows_for_generic_args)]
3835 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3836 }
3837 if !self.scores.is_empty() {
3838 struct_ser.serialize_field("scores", &self.scores)?;
3839 }
3840 struct_ser.end()
3841 }
3842}
3843impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
3844 #[allow(deprecated)]
3845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3846 where
3847 D: serde::Deserializer<'de>,
3848 {
3849 const FIELDS: &[&str] = &[
3850 "compaction_group_id",
3851 "compactionGroupId",
3852 "scores",
3853 ];
3854
3855 #[allow(clippy::enum_variant_names)]
3856 enum GeneratedField {
3857 CompactionGroupId,
3858 Scores,
3859 }
3860 impl<'de> serde::Deserialize<'de> for GeneratedField {
3861 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3862 where
3863 D: serde::Deserializer<'de>,
3864 {
3865 struct GeneratedVisitor;
3866
3867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3868 type Value = GeneratedField;
3869
3870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3871 write!(formatter, "expected one of: {:?}", &FIELDS)
3872 }
3873
3874 #[allow(unused_variables)]
3875 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3876 where
3877 E: serde::de::Error,
3878 {
3879 match value {
3880 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3881 "scores" => Ok(GeneratedField::Scores),
3882 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3883 }
3884 }
3885 }
3886 deserializer.deserialize_identifier(GeneratedVisitor)
3887 }
3888 }
3889 struct GeneratedVisitor;
3890 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3891 type Value = GetCompactionScoreResponse;
3892
3893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3894 formatter.write_str("struct hummock.GetCompactionScoreResponse")
3895 }
3896
3897 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
3898 where
3899 V: serde::de::MapAccess<'de>,
3900 {
3901 let mut compaction_group_id__ = None;
3902 let mut scores__ = None;
3903 while let Some(k) = map_.next_key()? {
3904 match k {
3905 GeneratedField::CompactionGroupId => {
3906 if compaction_group_id__.is_some() {
3907 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3908 }
3909 compaction_group_id__ =
3910 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3911 ;
3912 }
3913 GeneratedField::Scores => {
3914 if scores__.is_some() {
3915 return Err(serde::de::Error::duplicate_field("scores"));
3916 }
3917 scores__ = Some(map_.next_value()?);
3918 }
3919 }
3920 }
3921 Ok(GetCompactionScoreResponse {
3922 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3923 scores: scores__.unwrap_or_default(),
3924 })
3925 }
3926 }
3927 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
3928 }
3929}
3930impl serde::Serialize for get_compaction_score_response::PickerInfo {
3931 #[allow(deprecated)]
3932 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3933 where
3934 S: serde::Serializer,
3935 {
3936 use serde::ser::SerializeStruct;
3937 let mut len = 0;
3938 if self.score != 0 {
3939 len += 1;
3940 }
3941 if self.select_level != 0 {
3942 len += 1;
3943 }
3944 if self.target_level != 0 {
3945 len += 1;
3946 }
3947 if !self.picker_type.is_empty() {
3948 len += 1;
3949 }
3950 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
3951 if self.score != 0 {
3952 #[allow(clippy::needless_borrow)]
3953 #[allow(clippy::needless_borrows_for_generic_args)]
3954 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
3955 }
3956 if self.select_level != 0 {
3957 #[allow(clippy::needless_borrow)]
3958 #[allow(clippy::needless_borrows_for_generic_args)]
3959 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
3960 }
3961 if self.target_level != 0 {
3962 #[allow(clippy::needless_borrow)]
3963 #[allow(clippy::needless_borrows_for_generic_args)]
3964 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
3965 }
3966 if !self.picker_type.is_empty() {
3967 struct_ser.serialize_field("pickerType", &self.picker_type)?;
3968 }
3969 struct_ser.end()
3970 }
3971}
3972impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
3973 #[allow(deprecated)]
3974 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3975 where
3976 D: serde::Deserializer<'de>,
3977 {
3978 const FIELDS: &[&str] = &[
3979 "score",
3980 "select_level",
3981 "selectLevel",
3982 "target_level",
3983 "targetLevel",
3984 "picker_type",
3985 "pickerType",
3986 ];
3987
3988 #[allow(clippy::enum_variant_names)]
3989 enum GeneratedField {
3990 Score,
3991 SelectLevel,
3992 TargetLevel,
3993 PickerType,
3994 }
3995 impl<'de> serde::Deserialize<'de> for GeneratedField {
3996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3997 where
3998 D: serde::Deserializer<'de>,
3999 {
4000 struct GeneratedVisitor;
4001
4002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4003 type Value = GeneratedField;
4004
4005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4006 write!(formatter, "expected one of: {:?}", &FIELDS)
4007 }
4008
4009 #[allow(unused_variables)]
4010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4011 where
4012 E: serde::de::Error,
4013 {
4014 match value {
4015 "score" => Ok(GeneratedField::Score),
4016 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4017 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4018 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4019 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4020 }
4021 }
4022 }
4023 deserializer.deserialize_identifier(GeneratedVisitor)
4024 }
4025 }
4026 struct GeneratedVisitor;
4027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4028 type Value = get_compaction_score_response::PickerInfo;
4029
4030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4031 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4032 }
4033
4034 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4035 where
4036 V: serde::de::MapAccess<'de>,
4037 {
4038 let mut score__ = None;
4039 let mut select_level__ = None;
4040 let mut target_level__ = None;
4041 let mut picker_type__ = None;
4042 while let Some(k) = map_.next_key()? {
4043 match k {
4044 GeneratedField::Score => {
4045 if score__.is_some() {
4046 return Err(serde::de::Error::duplicate_field("score"));
4047 }
4048 score__ =
4049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4050 ;
4051 }
4052 GeneratedField::SelectLevel => {
4053 if select_level__.is_some() {
4054 return Err(serde::de::Error::duplicate_field("selectLevel"));
4055 }
4056 select_level__ =
4057 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4058 ;
4059 }
4060 GeneratedField::TargetLevel => {
4061 if target_level__.is_some() {
4062 return Err(serde::de::Error::duplicate_field("targetLevel"));
4063 }
4064 target_level__ =
4065 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4066 ;
4067 }
4068 GeneratedField::PickerType => {
4069 if picker_type__.is_some() {
4070 return Err(serde::de::Error::duplicate_field("pickerType"));
4071 }
4072 picker_type__ = Some(map_.next_value()?);
4073 }
4074 }
4075 }
4076 Ok(get_compaction_score_response::PickerInfo {
4077 score: score__.unwrap_or_default(),
4078 select_level: select_level__.unwrap_or_default(),
4079 target_level: target_level__.unwrap_or_default(),
4080 picker_type: picker_type__.unwrap_or_default(),
4081 })
4082 }
4083 }
4084 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4085 }
4086}
4087impl serde::Serialize for GetCurrentVersionRequest {
4088 #[allow(deprecated)]
4089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4090 where
4091 S: serde::Serializer,
4092 {
4093 use serde::ser::SerializeStruct;
4094 let len = 0;
4095 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4096 struct_ser.end()
4097 }
4098}
4099impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4100 #[allow(deprecated)]
4101 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4102 where
4103 D: serde::Deserializer<'de>,
4104 {
4105 const FIELDS: &[&str] = &[
4106 ];
4107
4108 #[allow(clippy::enum_variant_names)]
4109 enum GeneratedField {
4110 }
4111 impl<'de> serde::Deserialize<'de> for GeneratedField {
4112 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4113 where
4114 D: serde::Deserializer<'de>,
4115 {
4116 struct GeneratedVisitor;
4117
4118 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4119 type Value = GeneratedField;
4120
4121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4122 write!(formatter, "expected one of: {:?}", &FIELDS)
4123 }
4124
4125 #[allow(unused_variables)]
4126 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4127 where
4128 E: serde::de::Error,
4129 {
4130 Err(serde::de::Error::unknown_field(value, FIELDS))
4131 }
4132 }
4133 deserializer.deserialize_identifier(GeneratedVisitor)
4134 }
4135 }
4136 struct GeneratedVisitor;
4137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4138 type Value = GetCurrentVersionRequest;
4139
4140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4141 formatter.write_str("struct hummock.GetCurrentVersionRequest")
4142 }
4143
4144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4145 where
4146 V: serde::de::MapAccess<'de>,
4147 {
4148 while map_.next_key::<GeneratedField>()?.is_some() {
4149 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4150 }
4151 Ok(GetCurrentVersionRequest {
4152 })
4153 }
4154 }
4155 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4156 }
4157}
4158impl serde::Serialize for GetCurrentVersionResponse {
4159 #[allow(deprecated)]
4160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4161 where
4162 S: serde::Serializer,
4163 {
4164 use serde::ser::SerializeStruct;
4165 let mut len = 0;
4166 if self.status.is_some() {
4167 len += 1;
4168 }
4169 if self.current_version.is_some() {
4170 len += 1;
4171 }
4172 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4173 if let Some(v) = self.status.as_ref() {
4174 struct_ser.serialize_field("status", v)?;
4175 }
4176 if let Some(v) = self.current_version.as_ref() {
4177 struct_ser.serialize_field("currentVersion", v)?;
4178 }
4179 struct_ser.end()
4180 }
4181}
4182impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4183 #[allow(deprecated)]
4184 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4185 where
4186 D: serde::Deserializer<'de>,
4187 {
4188 const FIELDS: &[&str] = &[
4189 "status",
4190 "current_version",
4191 "currentVersion",
4192 ];
4193
4194 #[allow(clippy::enum_variant_names)]
4195 enum GeneratedField {
4196 Status,
4197 CurrentVersion,
4198 }
4199 impl<'de> serde::Deserialize<'de> for GeneratedField {
4200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4201 where
4202 D: serde::Deserializer<'de>,
4203 {
4204 struct GeneratedVisitor;
4205
4206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4207 type Value = GeneratedField;
4208
4209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4210 write!(formatter, "expected one of: {:?}", &FIELDS)
4211 }
4212
4213 #[allow(unused_variables)]
4214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4215 where
4216 E: serde::de::Error,
4217 {
4218 match value {
4219 "status" => Ok(GeneratedField::Status),
4220 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4222 }
4223 }
4224 }
4225 deserializer.deserialize_identifier(GeneratedVisitor)
4226 }
4227 }
4228 struct GeneratedVisitor;
4229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4230 type Value = GetCurrentVersionResponse;
4231
4232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4233 formatter.write_str("struct hummock.GetCurrentVersionResponse")
4234 }
4235
4236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4237 where
4238 V: serde::de::MapAccess<'de>,
4239 {
4240 let mut status__ = None;
4241 let mut current_version__ = None;
4242 while let Some(k) = map_.next_key()? {
4243 match k {
4244 GeneratedField::Status => {
4245 if status__.is_some() {
4246 return Err(serde::de::Error::duplicate_field("status"));
4247 }
4248 status__ = map_.next_value()?;
4249 }
4250 GeneratedField::CurrentVersion => {
4251 if current_version__.is_some() {
4252 return Err(serde::de::Error::duplicate_field("currentVersion"));
4253 }
4254 current_version__ = map_.next_value()?;
4255 }
4256 }
4257 }
4258 Ok(GetCurrentVersionResponse {
4259 status: status__,
4260 current_version: current_version__,
4261 })
4262 }
4263 }
4264 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4265 }
4266}
4267impl serde::Serialize for GetNewObjectIdsRequest {
4268 #[allow(deprecated)]
4269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4270 where
4271 S: serde::Serializer,
4272 {
4273 use serde::ser::SerializeStruct;
4274 let mut len = 0;
4275 if self.number != 0 {
4276 len += 1;
4277 }
4278 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4279 if self.number != 0 {
4280 struct_ser.serialize_field("number", &self.number)?;
4281 }
4282 struct_ser.end()
4283 }
4284}
4285impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4286 #[allow(deprecated)]
4287 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4288 where
4289 D: serde::Deserializer<'de>,
4290 {
4291 const FIELDS: &[&str] = &[
4292 "number",
4293 ];
4294
4295 #[allow(clippy::enum_variant_names)]
4296 enum GeneratedField {
4297 Number,
4298 }
4299 impl<'de> serde::Deserialize<'de> for GeneratedField {
4300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4301 where
4302 D: serde::Deserializer<'de>,
4303 {
4304 struct GeneratedVisitor;
4305
4306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4307 type Value = GeneratedField;
4308
4309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4310 write!(formatter, "expected one of: {:?}", &FIELDS)
4311 }
4312
4313 #[allow(unused_variables)]
4314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4315 where
4316 E: serde::de::Error,
4317 {
4318 match value {
4319 "number" => Ok(GeneratedField::Number),
4320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4321 }
4322 }
4323 }
4324 deserializer.deserialize_identifier(GeneratedVisitor)
4325 }
4326 }
4327 struct GeneratedVisitor;
4328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4329 type Value = GetNewObjectIdsRequest;
4330
4331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4332 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4333 }
4334
4335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4336 where
4337 V: serde::de::MapAccess<'de>,
4338 {
4339 let mut number__ = None;
4340 while let Some(k) = map_.next_key()? {
4341 match k {
4342 GeneratedField::Number => {
4343 if number__.is_some() {
4344 return Err(serde::de::Error::duplicate_field("number"));
4345 }
4346 number__ =
4347 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4348 ;
4349 }
4350 }
4351 }
4352 Ok(GetNewObjectIdsRequest {
4353 number: number__.unwrap_or_default(),
4354 })
4355 }
4356 }
4357 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4358 }
4359}
4360impl serde::Serialize for GetNewObjectIdsResponse {
4361 #[allow(deprecated)]
4362 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4363 where
4364 S: serde::Serializer,
4365 {
4366 use serde::ser::SerializeStruct;
4367 let mut len = 0;
4368 if self.status.is_some() {
4369 len += 1;
4370 }
4371 if self.start_id != 0 {
4372 len += 1;
4373 }
4374 if self.end_id != 0 {
4375 len += 1;
4376 }
4377 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4378 if let Some(v) = self.status.as_ref() {
4379 struct_ser.serialize_field("status", v)?;
4380 }
4381 if self.start_id != 0 {
4382 #[allow(clippy::needless_borrow)]
4383 #[allow(clippy::needless_borrows_for_generic_args)]
4384 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4385 }
4386 if self.end_id != 0 {
4387 #[allow(clippy::needless_borrow)]
4388 #[allow(clippy::needless_borrows_for_generic_args)]
4389 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4390 }
4391 struct_ser.end()
4392 }
4393}
4394impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4395 #[allow(deprecated)]
4396 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4397 where
4398 D: serde::Deserializer<'de>,
4399 {
4400 const FIELDS: &[&str] = &[
4401 "status",
4402 "start_id",
4403 "startId",
4404 "end_id",
4405 "endId",
4406 ];
4407
4408 #[allow(clippy::enum_variant_names)]
4409 enum GeneratedField {
4410 Status,
4411 StartId,
4412 EndId,
4413 }
4414 impl<'de> serde::Deserialize<'de> for GeneratedField {
4415 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4416 where
4417 D: serde::Deserializer<'de>,
4418 {
4419 struct GeneratedVisitor;
4420
4421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4422 type Value = GeneratedField;
4423
4424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4425 write!(formatter, "expected one of: {:?}", &FIELDS)
4426 }
4427
4428 #[allow(unused_variables)]
4429 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4430 where
4431 E: serde::de::Error,
4432 {
4433 match value {
4434 "status" => Ok(GeneratedField::Status),
4435 "startId" | "start_id" => Ok(GeneratedField::StartId),
4436 "endId" | "end_id" => Ok(GeneratedField::EndId),
4437 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4438 }
4439 }
4440 }
4441 deserializer.deserialize_identifier(GeneratedVisitor)
4442 }
4443 }
4444 struct GeneratedVisitor;
4445 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4446 type Value = GetNewObjectIdsResponse;
4447
4448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4449 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4450 }
4451
4452 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4453 where
4454 V: serde::de::MapAccess<'de>,
4455 {
4456 let mut status__ = None;
4457 let mut start_id__ = None;
4458 let mut end_id__ = None;
4459 while let Some(k) = map_.next_key()? {
4460 match k {
4461 GeneratedField::Status => {
4462 if status__.is_some() {
4463 return Err(serde::de::Error::duplicate_field("status"));
4464 }
4465 status__ = map_.next_value()?;
4466 }
4467 GeneratedField::StartId => {
4468 if start_id__.is_some() {
4469 return Err(serde::de::Error::duplicate_field("startId"));
4470 }
4471 start_id__ =
4472 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4473 ;
4474 }
4475 GeneratedField::EndId => {
4476 if end_id__.is_some() {
4477 return Err(serde::de::Error::duplicate_field("endId"));
4478 }
4479 end_id__ =
4480 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4481 ;
4482 }
4483 }
4484 }
4485 Ok(GetNewObjectIdsResponse {
4486 status: status__,
4487 start_id: start_id__.unwrap_or_default(),
4488 end_id: end_id__.unwrap_or_default(),
4489 })
4490 }
4491 }
4492 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4493 }
4494}
4495impl serde::Serialize for GetVersionByEpochRequest {
4496 #[allow(deprecated)]
4497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4498 where
4499 S: serde::Serializer,
4500 {
4501 use serde::ser::SerializeStruct;
4502 let mut len = 0;
4503 if self.epoch != 0 {
4504 len += 1;
4505 }
4506 if self.table_id != 0 {
4507 len += 1;
4508 }
4509 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
4510 if self.epoch != 0 {
4511 #[allow(clippy::needless_borrow)]
4512 #[allow(clippy::needless_borrows_for_generic_args)]
4513 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
4514 }
4515 if self.table_id != 0 {
4516 struct_ser.serialize_field("tableId", &self.table_id)?;
4517 }
4518 struct_ser.end()
4519 }
4520}
4521impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
4522 #[allow(deprecated)]
4523 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4524 where
4525 D: serde::Deserializer<'de>,
4526 {
4527 const FIELDS: &[&str] = &[
4528 "epoch",
4529 "table_id",
4530 "tableId",
4531 ];
4532
4533 #[allow(clippy::enum_variant_names)]
4534 enum GeneratedField {
4535 Epoch,
4536 TableId,
4537 }
4538 impl<'de> serde::Deserialize<'de> for GeneratedField {
4539 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4540 where
4541 D: serde::Deserializer<'de>,
4542 {
4543 struct GeneratedVisitor;
4544
4545 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4546 type Value = GeneratedField;
4547
4548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4549 write!(formatter, "expected one of: {:?}", &FIELDS)
4550 }
4551
4552 #[allow(unused_variables)]
4553 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4554 where
4555 E: serde::de::Error,
4556 {
4557 match value {
4558 "epoch" => Ok(GeneratedField::Epoch),
4559 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4561 }
4562 }
4563 }
4564 deserializer.deserialize_identifier(GeneratedVisitor)
4565 }
4566 }
4567 struct GeneratedVisitor;
4568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4569 type Value = GetVersionByEpochRequest;
4570
4571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4572 formatter.write_str("struct hummock.GetVersionByEpochRequest")
4573 }
4574
4575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
4576 where
4577 V: serde::de::MapAccess<'de>,
4578 {
4579 let mut epoch__ = None;
4580 let mut table_id__ = None;
4581 while let Some(k) = map_.next_key()? {
4582 match k {
4583 GeneratedField::Epoch => {
4584 if epoch__.is_some() {
4585 return Err(serde::de::Error::duplicate_field("epoch"));
4586 }
4587 epoch__ =
4588 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4589 ;
4590 }
4591 GeneratedField::TableId => {
4592 if table_id__.is_some() {
4593 return Err(serde::de::Error::duplicate_field("tableId"));
4594 }
4595 table_id__ =
4596 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4597 ;
4598 }
4599 }
4600 }
4601 Ok(GetVersionByEpochRequest {
4602 epoch: epoch__.unwrap_or_default(),
4603 table_id: table_id__.unwrap_or_default(),
4604 })
4605 }
4606 }
4607 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
4608 }
4609}
4610impl serde::Serialize for GetVersionByEpochResponse {
4611 #[allow(deprecated)]
4612 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4613 where
4614 S: serde::Serializer,
4615 {
4616 use serde::ser::SerializeStruct;
4617 let mut len = 0;
4618 if self.version.is_some() {
4619 len += 1;
4620 }
4621 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
4622 if let Some(v) = self.version.as_ref() {
4623 struct_ser.serialize_field("version", v)?;
4624 }
4625 struct_ser.end()
4626 }
4627}
4628impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
4629 #[allow(deprecated)]
4630 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4631 where
4632 D: serde::Deserializer<'de>,
4633 {
4634 const FIELDS: &[&str] = &[
4635 "version",
4636 ];
4637
4638 #[allow(clippy::enum_variant_names)]
4639 enum GeneratedField {
4640 Version,
4641 }
4642 impl<'de> serde::Deserialize<'de> for GeneratedField {
4643 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4644 where
4645 D: serde::Deserializer<'de>,
4646 {
4647 struct GeneratedVisitor;
4648
4649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4650 type Value = GeneratedField;
4651
4652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4653 write!(formatter, "expected one of: {:?}", &FIELDS)
4654 }
4655
4656 #[allow(unused_variables)]
4657 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4658 where
4659 E: serde::de::Error,
4660 {
4661 match value {
4662 "version" => Ok(GeneratedField::Version),
4663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4664 }
4665 }
4666 }
4667 deserializer.deserialize_identifier(GeneratedVisitor)
4668 }
4669 }
4670 struct GeneratedVisitor;
4671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4672 type Value = GetVersionByEpochResponse;
4673
4674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4675 formatter.write_str("struct hummock.GetVersionByEpochResponse")
4676 }
4677
4678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
4679 where
4680 V: serde::de::MapAccess<'de>,
4681 {
4682 let mut version__ = None;
4683 while let Some(k) = map_.next_key()? {
4684 match k {
4685 GeneratedField::Version => {
4686 if version__.is_some() {
4687 return Err(serde::de::Error::duplicate_field("version"));
4688 }
4689 version__ = map_.next_value()?;
4690 }
4691 }
4692 }
4693 Ok(GetVersionByEpochResponse {
4694 version: version__,
4695 })
4696 }
4697 }
4698 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
4699 }
4700}
4701impl serde::Serialize for GroupConstruct {
4702 #[allow(deprecated)]
4703 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4704 where
4705 S: serde::Serializer,
4706 {
4707 use serde::ser::SerializeStruct;
4708 let mut len = 0;
4709 if self.group_config.is_some() {
4710 len += 1;
4711 }
4712 if self.parent_group_id != 0 {
4713 len += 1;
4714 }
4715 if !self.table_ids.is_empty() {
4716 len += 1;
4717 }
4718 if self.group_id != 0 {
4719 len += 1;
4720 }
4721 if self.new_sst_start_id != 0 {
4722 len += 1;
4723 }
4724 if self.version != 0 {
4725 len += 1;
4726 }
4727 if self.split_key.is_some() {
4728 len += 1;
4729 }
4730 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
4731 if let Some(v) = self.group_config.as_ref() {
4732 struct_ser.serialize_field("groupConfig", v)?;
4733 }
4734 if self.parent_group_id != 0 {
4735 #[allow(clippy::needless_borrow)]
4736 #[allow(clippy::needless_borrows_for_generic_args)]
4737 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
4738 }
4739 if !self.table_ids.is_empty() {
4740 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4741 }
4742 if self.group_id != 0 {
4743 #[allow(clippy::needless_borrow)]
4744 #[allow(clippy::needless_borrows_for_generic_args)]
4745 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
4746 }
4747 if self.new_sst_start_id != 0 {
4748 #[allow(clippy::needless_borrow)]
4749 #[allow(clippy::needless_borrows_for_generic_args)]
4750 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
4751 }
4752 if self.version != 0 {
4753 let v = CompatibilityVersion::try_from(self.version)
4754 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4755 struct_ser.serialize_field("version", &v)?;
4756 }
4757 if let Some(v) = self.split_key.as_ref() {
4758 #[allow(clippy::needless_borrow)]
4759 #[allow(clippy::needless_borrows_for_generic_args)]
4760 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
4761 }
4762 struct_ser.end()
4763 }
4764}
4765impl<'de> serde::Deserialize<'de> for GroupConstruct {
4766 #[allow(deprecated)]
4767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4768 where
4769 D: serde::Deserializer<'de>,
4770 {
4771 const FIELDS: &[&str] = &[
4772 "group_config",
4773 "groupConfig",
4774 "parent_group_id",
4775 "parentGroupId",
4776 "table_ids",
4777 "tableIds",
4778 "group_id",
4779 "groupId",
4780 "new_sst_start_id",
4781 "newSstStartId",
4782 "version",
4783 "split_key",
4784 "splitKey",
4785 ];
4786
4787 #[allow(clippy::enum_variant_names)]
4788 enum GeneratedField {
4789 GroupConfig,
4790 ParentGroupId,
4791 TableIds,
4792 GroupId,
4793 NewSstStartId,
4794 Version,
4795 SplitKey,
4796 }
4797 impl<'de> serde::Deserialize<'de> for GeneratedField {
4798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4799 where
4800 D: serde::Deserializer<'de>,
4801 {
4802 struct GeneratedVisitor;
4803
4804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4805 type Value = GeneratedField;
4806
4807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4808 write!(formatter, "expected one of: {:?}", &FIELDS)
4809 }
4810
4811 #[allow(unused_variables)]
4812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4813 where
4814 E: serde::de::Error,
4815 {
4816 match value {
4817 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
4818 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
4819 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4820 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
4821 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
4822 "version" => Ok(GeneratedField::Version),
4823 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
4824 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4825 }
4826 }
4827 }
4828 deserializer.deserialize_identifier(GeneratedVisitor)
4829 }
4830 }
4831 struct GeneratedVisitor;
4832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4833 type Value = GroupConstruct;
4834
4835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4836 formatter.write_str("struct hummock.GroupConstruct")
4837 }
4838
4839 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
4840 where
4841 V: serde::de::MapAccess<'de>,
4842 {
4843 let mut group_config__ = None;
4844 let mut parent_group_id__ = None;
4845 let mut table_ids__ = None;
4846 let mut group_id__ = None;
4847 let mut new_sst_start_id__ = None;
4848 let mut version__ = None;
4849 let mut split_key__ = None;
4850 while let Some(k) = map_.next_key()? {
4851 match k {
4852 GeneratedField::GroupConfig => {
4853 if group_config__.is_some() {
4854 return Err(serde::de::Error::duplicate_field("groupConfig"));
4855 }
4856 group_config__ = map_.next_value()?;
4857 }
4858 GeneratedField::ParentGroupId => {
4859 if parent_group_id__.is_some() {
4860 return Err(serde::de::Error::duplicate_field("parentGroupId"));
4861 }
4862 parent_group_id__ =
4863 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4864 ;
4865 }
4866 GeneratedField::TableIds => {
4867 if table_ids__.is_some() {
4868 return Err(serde::de::Error::duplicate_field("tableIds"));
4869 }
4870 table_ids__ =
4871 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4872 .into_iter().map(|x| x.0).collect())
4873 ;
4874 }
4875 GeneratedField::GroupId => {
4876 if group_id__.is_some() {
4877 return Err(serde::de::Error::duplicate_field("groupId"));
4878 }
4879 group_id__ =
4880 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4881 ;
4882 }
4883 GeneratedField::NewSstStartId => {
4884 if new_sst_start_id__.is_some() {
4885 return Err(serde::de::Error::duplicate_field("newSstStartId"));
4886 }
4887 new_sst_start_id__ =
4888 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4889 ;
4890 }
4891 GeneratedField::Version => {
4892 if version__.is_some() {
4893 return Err(serde::de::Error::duplicate_field("version"));
4894 }
4895 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
4896 }
4897 GeneratedField::SplitKey => {
4898 if split_key__.is_some() {
4899 return Err(serde::de::Error::duplicate_field("splitKey"));
4900 }
4901 split_key__ =
4902 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
4903 ;
4904 }
4905 }
4906 }
4907 Ok(GroupConstruct {
4908 group_config: group_config__,
4909 parent_group_id: parent_group_id__.unwrap_or_default(),
4910 table_ids: table_ids__.unwrap_or_default(),
4911 group_id: group_id__.unwrap_or_default(),
4912 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
4913 version: version__.unwrap_or_default(),
4914 split_key: split_key__,
4915 })
4916 }
4917 }
4918 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
4919 }
4920}
4921impl serde::Serialize for GroupDelta {
4922 #[allow(deprecated)]
4923 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4924 where
4925 S: serde::Serializer,
4926 {
4927 use serde::ser::SerializeStruct;
4928 let mut len = 0;
4929 if self.delta_type.is_some() {
4930 len += 1;
4931 }
4932 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
4933 if let Some(v) = self.delta_type.as_ref() {
4934 match v {
4935 group_delta::DeltaType::IntraLevel(v) => {
4936 struct_ser.serialize_field("intraLevel", v)?;
4937 }
4938 group_delta::DeltaType::GroupConstruct(v) => {
4939 struct_ser.serialize_field("groupConstruct", v)?;
4940 }
4941 group_delta::DeltaType::GroupDestroy(v) => {
4942 struct_ser.serialize_field("groupDestroy", v)?;
4943 }
4944 group_delta::DeltaType::GroupMerge(v) => {
4945 struct_ser.serialize_field("groupMerge", v)?;
4946 }
4947 group_delta::DeltaType::NewL0SubLevel(v) => {
4948 struct_ser.serialize_field("newL0SubLevel", v)?;
4949 }
4950 group_delta::DeltaType::TruncateTables(v) => {
4951 struct_ser.serialize_field("truncateTables", v)?;
4952 }
4953 }
4954 }
4955 struct_ser.end()
4956 }
4957}
4958impl<'de> serde::Deserialize<'de> for GroupDelta {
4959 #[allow(deprecated)]
4960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4961 where
4962 D: serde::Deserializer<'de>,
4963 {
4964 const FIELDS: &[&str] = &[
4965 "intra_level",
4966 "intraLevel",
4967 "group_construct",
4968 "groupConstruct",
4969 "group_destroy",
4970 "groupDestroy",
4971 "group_merge",
4972 "groupMerge",
4973 "new_l0_sub_level",
4974 "newL0SubLevel",
4975 "truncate_tables",
4976 "truncateTables",
4977 ];
4978
4979 #[allow(clippy::enum_variant_names)]
4980 enum GeneratedField {
4981 IntraLevel,
4982 GroupConstruct,
4983 GroupDestroy,
4984 GroupMerge,
4985 NewL0SubLevel,
4986 TruncateTables,
4987 }
4988 impl<'de> serde::Deserialize<'de> for GeneratedField {
4989 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4990 where
4991 D: serde::Deserializer<'de>,
4992 {
4993 struct GeneratedVisitor;
4994
4995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4996 type Value = GeneratedField;
4997
4998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4999 write!(formatter, "expected one of: {:?}", &FIELDS)
5000 }
5001
5002 #[allow(unused_variables)]
5003 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5004 where
5005 E: serde::de::Error,
5006 {
5007 match value {
5008 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5009 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5010 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5011 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5012 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5013 "truncateTables" | "truncate_tables" => Ok(GeneratedField::TruncateTables),
5014 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5015 }
5016 }
5017 }
5018 deserializer.deserialize_identifier(GeneratedVisitor)
5019 }
5020 }
5021 struct GeneratedVisitor;
5022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5023 type Value = GroupDelta;
5024
5025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5026 formatter.write_str("struct hummock.GroupDelta")
5027 }
5028
5029 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5030 where
5031 V: serde::de::MapAccess<'de>,
5032 {
5033 let mut delta_type__ = None;
5034 while let Some(k) = map_.next_key()? {
5035 match k {
5036 GeneratedField::IntraLevel => {
5037 if delta_type__.is_some() {
5038 return Err(serde::de::Error::duplicate_field("intraLevel"));
5039 }
5040 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5041;
5042 }
5043 GeneratedField::GroupConstruct => {
5044 if delta_type__.is_some() {
5045 return Err(serde::de::Error::duplicate_field("groupConstruct"));
5046 }
5047 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5048;
5049 }
5050 GeneratedField::GroupDestroy => {
5051 if delta_type__.is_some() {
5052 return Err(serde::de::Error::duplicate_field("groupDestroy"));
5053 }
5054 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5055;
5056 }
5057 GeneratedField::GroupMerge => {
5058 if delta_type__.is_some() {
5059 return Err(serde::de::Error::duplicate_field("groupMerge"));
5060 }
5061 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5062;
5063 }
5064 GeneratedField::NewL0SubLevel => {
5065 if delta_type__.is_some() {
5066 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5067 }
5068 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5069;
5070 }
5071 GeneratedField::TruncateTables => {
5072 if delta_type__.is_some() {
5073 return Err(serde::de::Error::duplicate_field("truncateTables"));
5074 }
5075 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::TruncateTables)
5076;
5077 }
5078 }
5079 }
5080 Ok(GroupDelta {
5081 delta_type: delta_type__,
5082 })
5083 }
5084 }
5085 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5086 }
5087}
5088impl serde::Serialize for GroupDestroy {
5089 #[allow(deprecated)]
5090 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5091 where
5092 S: serde::Serializer,
5093 {
5094 use serde::ser::SerializeStruct;
5095 let len = 0;
5096 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5097 struct_ser.end()
5098 }
5099}
5100impl<'de> serde::Deserialize<'de> for GroupDestroy {
5101 #[allow(deprecated)]
5102 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5103 where
5104 D: serde::Deserializer<'de>,
5105 {
5106 const FIELDS: &[&str] = &[
5107 ];
5108
5109 #[allow(clippy::enum_variant_names)]
5110 enum GeneratedField {
5111 }
5112 impl<'de> serde::Deserialize<'de> for GeneratedField {
5113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5114 where
5115 D: serde::Deserializer<'de>,
5116 {
5117 struct GeneratedVisitor;
5118
5119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5120 type Value = GeneratedField;
5121
5122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5123 write!(formatter, "expected one of: {:?}", &FIELDS)
5124 }
5125
5126 #[allow(unused_variables)]
5127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5128 where
5129 E: serde::de::Error,
5130 {
5131 Err(serde::de::Error::unknown_field(value, FIELDS))
5132 }
5133 }
5134 deserializer.deserialize_identifier(GeneratedVisitor)
5135 }
5136 }
5137 struct GeneratedVisitor;
5138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5139 type Value = GroupDestroy;
5140
5141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5142 formatter.write_str("struct hummock.GroupDestroy")
5143 }
5144
5145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5146 where
5147 V: serde::de::MapAccess<'de>,
5148 {
5149 while map_.next_key::<GeneratedField>()?.is_some() {
5150 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5151 }
5152 Ok(GroupDestroy {
5153 })
5154 }
5155 }
5156 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5157 }
5158}
5159impl serde::Serialize for GroupMerge {
5160 #[allow(deprecated)]
5161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5162 where
5163 S: serde::Serializer,
5164 {
5165 use serde::ser::SerializeStruct;
5166 let mut len = 0;
5167 if self.left_group_id != 0 {
5168 len += 1;
5169 }
5170 if self.right_group_id != 0 {
5171 len += 1;
5172 }
5173 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5174 if self.left_group_id != 0 {
5175 #[allow(clippy::needless_borrow)]
5176 #[allow(clippy::needless_borrows_for_generic_args)]
5177 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5178 }
5179 if self.right_group_id != 0 {
5180 #[allow(clippy::needless_borrow)]
5181 #[allow(clippy::needless_borrows_for_generic_args)]
5182 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5183 }
5184 struct_ser.end()
5185 }
5186}
5187impl<'de> serde::Deserialize<'de> for GroupMerge {
5188 #[allow(deprecated)]
5189 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5190 where
5191 D: serde::Deserializer<'de>,
5192 {
5193 const FIELDS: &[&str] = &[
5194 "left_group_id",
5195 "leftGroupId",
5196 "right_group_id",
5197 "rightGroupId",
5198 ];
5199
5200 #[allow(clippy::enum_variant_names)]
5201 enum GeneratedField {
5202 LeftGroupId,
5203 RightGroupId,
5204 }
5205 impl<'de> serde::Deserialize<'de> for GeneratedField {
5206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5207 where
5208 D: serde::Deserializer<'de>,
5209 {
5210 struct GeneratedVisitor;
5211
5212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5213 type Value = GeneratedField;
5214
5215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5216 write!(formatter, "expected one of: {:?}", &FIELDS)
5217 }
5218
5219 #[allow(unused_variables)]
5220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5221 where
5222 E: serde::de::Error,
5223 {
5224 match value {
5225 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5226 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5227 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5228 }
5229 }
5230 }
5231 deserializer.deserialize_identifier(GeneratedVisitor)
5232 }
5233 }
5234 struct GeneratedVisitor;
5235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5236 type Value = GroupMerge;
5237
5238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5239 formatter.write_str("struct hummock.GroupMerge")
5240 }
5241
5242 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5243 where
5244 V: serde::de::MapAccess<'de>,
5245 {
5246 let mut left_group_id__ = None;
5247 let mut right_group_id__ = None;
5248 while let Some(k) = map_.next_key()? {
5249 match k {
5250 GeneratedField::LeftGroupId => {
5251 if left_group_id__.is_some() {
5252 return Err(serde::de::Error::duplicate_field("leftGroupId"));
5253 }
5254 left_group_id__ =
5255 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5256 ;
5257 }
5258 GeneratedField::RightGroupId => {
5259 if right_group_id__.is_some() {
5260 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5261 }
5262 right_group_id__ =
5263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5264 ;
5265 }
5266 }
5267 }
5268 Ok(GroupMerge {
5269 left_group_id: left_group_id__.unwrap_or_default(),
5270 right_group_id: right_group_id__.unwrap_or_default(),
5271 })
5272 }
5273 }
5274 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5275 }
5276}
5277impl serde::Serialize for HnswFlatIndex {
5278 #[allow(deprecated)]
5279 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5280 where
5281 S: serde::Serializer,
5282 {
5283 use serde::ser::SerializeStruct;
5284 let mut len = 0;
5285 if self.config.is_some() {
5286 len += 1;
5287 }
5288 if !self.vector_files.is_empty() {
5289 len += 1;
5290 }
5291 if self.next_vector_id != 0 {
5292 len += 1;
5293 }
5294 if self.graph_file.is_some() {
5295 len += 1;
5296 }
5297 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndex", len)?;
5298 if let Some(v) = self.config.as_ref() {
5299 struct_ser.serialize_field("config", v)?;
5300 }
5301 if !self.vector_files.is_empty() {
5302 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
5303 }
5304 if self.next_vector_id != 0 {
5305 #[allow(clippy::needless_borrow)]
5306 #[allow(clippy::needless_borrows_for_generic_args)]
5307 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5308 }
5309 if let Some(v) = self.graph_file.as_ref() {
5310 struct_ser.serialize_field("graphFile", v)?;
5311 }
5312 struct_ser.end()
5313 }
5314}
5315impl<'de> serde::Deserialize<'de> for HnswFlatIndex {
5316 #[allow(deprecated)]
5317 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5318 where
5319 D: serde::Deserializer<'de>,
5320 {
5321 const FIELDS: &[&str] = &[
5322 "config",
5323 "vector_files",
5324 "vectorFiles",
5325 "next_vector_id",
5326 "nextVectorId",
5327 "graph_file",
5328 "graphFile",
5329 ];
5330
5331 #[allow(clippy::enum_variant_names)]
5332 enum GeneratedField {
5333 Config,
5334 VectorFiles,
5335 NextVectorId,
5336 GraphFile,
5337 }
5338 impl<'de> serde::Deserialize<'de> for GeneratedField {
5339 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5340 where
5341 D: serde::Deserializer<'de>,
5342 {
5343 struct GeneratedVisitor;
5344
5345 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5346 type Value = GeneratedField;
5347
5348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5349 write!(formatter, "expected one of: {:?}", &FIELDS)
5350 }
5351
5352 #[allow(unused_variables)]
5353 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5354 where
5355 E: serde::de::Error,
5356 {
5357 match value {
5358 "config" => Ok(GeneratedField::Config),
5359 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
5360 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
5361 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
5362 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5363 }
5364 }
5365 }
5366 deserializer.deserialize_identifier(GeneratedVisitor)
5367 }
5368 }
5369 struct GeneratedVisitor;
5370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5371 type Value = HnswFlatIndex;
5372
5373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5374 formatter.write_str("struct hummock.HnswFlatIndex")
5375 }
5376
5377 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndex, V::Error>
5378 where
5379 V: serde::de::MapAccess<'de>,
5380 {
5381 let mut config__ = None;
5382 let mut vector_files__ = None;
5383 let mut next_vector_id__ = None;
5384 let mut graph_file__ = None;
5385 while let Some(k) = map_.next_key()? {
5386 match k {
5387 GeneratedField::Config => {
5388 if config__.is_some() {
5389 return Err(serde::de::Error::duplicate_field("config"));
5390 }
5391 config__ = map_.next_value()?;
5392 }
5393 GeneratedField::VectorFiles => {
5394 if vector_files__.is_some() {
5395 return Err(serde::de::Error::duplicate_field("vectorFiles"));
5396 }
5397 vector_files__ = Some(map_.next_value()?);
5398 }
5399 GeneratedField::NextVectorId => {
5400 if next_vector_id__.is_some() {
5401 return Err(serde::de::Error::duplicate_field("nextVectorId"));
5402 }
5403 next_vector_id__ =
5404 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5405 ;
5406 }
5407 GeneratedField::GraphFile => {
5408 if graph_file__.is_some() {
5409 return Err(serde::de::Error::duplicate_field("graphFile"));
5410 }
5411 graph_file__ = map_.next_value()?;
5412 }
5413 }
5414 }
5415 Ok(HnswFlatIndex {
5416 config: config__,
5417 vector_files: vector_files__.unwrap_or_default(),
5418 next_vector_id: next_vector_id__.unwrap_or_default(),
5419 graph_file: graph_file__,
5420 })
5421 }
5422 }
5423 deserializer.deserialize_struct("hummock.HnswFlatIndex", FIELDS, GeneratedVisitor)
5424 }
5425}
5426impl serde::Serialize for HnswFlatIndexAdd {
5427 #[allow(deprecated)]
5428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5429 where
5430 S: serde::Serializer,
5431 {
5432 use serde::ser::SerializeStruct;
5433 let mut len = 0;
5434 if !self.added_vector_files.is_empty() {
5435 len += 1;
5436 }
5437 if self.next_vector_id != 0 {
5438 len += 1;
5439 }
5440 if self.graph_file.is_some() {
5441 len += 1;
5442 }
5443 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndexAdd", len)?;
5444 if !self.added_vector_files.is_empty() {
5445 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
5446 }
5447 if self.next_vector_id != 0 {
5448 #[allow(clippy::needless_borrow)]
5449 #[allow(clippy::needless_borrows_for_generic_args)]
5450 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5451 }
5452 if let Some(v) = self.graph_file.as_ref() {
5453 struct_ser.serialize_field("graphFile", v)?;
5454 }
5455 struct_ser.end()
5456 }
5457}
5458impl<'de> serde::Deserialize<'de> for HnswFlatIndexAdd {
5459 #[allow(deprecated)]
5460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5461 where
5462 D: serde::Deserializer<'de>,
5463 {
5464 const FIELDS: &[&str] = &[
5465 "added_vector_files",
5466 "addedVectorFiles",
5467 "next_vector_id",
5468 "nextVectorId",
5469 "graph_file",
5470 "graphFile",
5471 ];
5472
5473 #[allow(clippy::enum_variant_names)]
5474 enum GeneratedField {
5475 AddedVectorFiles,
5476 NextVectorId,
5477 GraphFile,
5478 }
5479 impl<'de> serde::Deserialize<'de> for GeneratedField {
5480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5481 where
5482 D: serde::Deserializer<'de>,
5483 {
5484 struct GeneratedVisitor;
5485
5486 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5487 type Value = GeneratedField;
5488
5489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5490 write!(formatter, "expected one of: {:?}", &FIELDS)
5491 }
5492
5493 #[allow(unused_variables)]
5494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5495 where
5496 E: serde::de::Error,
5497 {
5498 match value {
5499 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
5500 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
5501 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
5502 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5503 }
5504 }
5505 }
5506 deserializer.deserialize_identifier(GeneratedVisitor)
5507 }
5508 }
5509 struct GeneratedVisitor;
5510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5511 type Value = HnswFlatIndexAdd;
5512
5513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5514 formatter.write_str("struct hummock.HnswFlatIndexAdd")
5515 }
5516
5517 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndexAdd, V::Error>
5518 where
5519 V: serde::de::MapAccess<'de>,
5520 {
5521 let mut added_vector_files__ = None;
5522 let mut next_vector_id__ = None;
5523 let mut graph_file__ = None;
5524 while let Some(k) = map_.next_key()? {
5525 match k {
5526 GeneratedField::AddedVectorFiles => {
5527 if added_vector_files__.is_some() {
5528 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
5529 }
5530 added_vector_files__ = Some(map_.next_value()?);
5531 }
5532 GeneratedField::NextVectorId => {
5533 if next_vector_id__.is_some() {
5534 return Err(serde::de::Error::duplicate_field("nextVectorId"));
5535 }
5536 next_vector_id__ =
5537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5538 ;
5539 }
5540 GeneratedField::GraphFile => {
5541 if graph_file__.is_some() {
5542 return Err(serde::de::Error::duplicate_field("graphFile"));
5543 }
5544 graph_file__ = map_.next_value()?;
5545 }
5546 }
5547 }
5548 Ok(HnswFlatIndexAdd {
5549 added_vector_files: added_vector_files__.unwrap_or_default(),
5550 next_vector_id: next_vector_id__.unwrap_or_default(),
5551 graph_file: graph_file__,
5552 })
5553 }
5554 }
5555 deserializer.deserialize_struct("hummock.HnswFlatIndexAdd", FIELDS, GeneratedVisitor)
5556 }
5557}
5558impl serde::Serialize for HnswGraph {
5559 #[allow(deprecated)]
5560 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5561 where
5562 S: serde::Serializer,
5563 {
5564 use serde::ser::SerializeStruct;
5565 let mut len = 0;
5566 if !self.nodes.is_empty() {
5567 len += 1;
5568 }
5569 if self.entrypoint_id != 0 {
5570 len += 1;
5571 }
5572 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph", len)?;
5573 if !self.nodes.is_empty() {
5574 struct_ser.serialize_field("nodes", &self.nodes)?;
5575 }
5576 if self.entrypoint_id != 0 {
5577 #[allow(clippy::needless_borrow)]
5578 #[allow(clippy::needless_borrows_for_generic_args)]
5579 struct_ser.serialize_field("entrypointId", ToString::to_string(&self.entrypoint_id).as_str())?;
5580 }
5581 struct_ser.end()
5582 }
5583}
5584impl<'de> serde::Deserialize<'de> for HnswGraph {
5585 #[allow(deprecated)]
5586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5587 where
5588 D: serde::Deserializer<'de>,
5589 {
5590 const FIELDS: &[&str] = &[
5591 "nodes",
5592 "entrypoint_id",
5593 "entrypointId",
5594 ];
5595
5596 #[allow(clippy::enum_variant_names)]
5597 enum GeneratedField {
5598 Nodes,
5599 EntrypointId,
5600 }
5601 impl<'de> serde::Deserialize<'de> for GeneratedField {
5602 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5603 where
5604 D: serde::Deserializer<'de>,
5605 {
5606 struct GeneratedVisitor;
5607
5608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5609 type Value = GeneratedField;
5610
5611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5612 write!(formatter, "expected one of: {:?}", &FIELDS)
5613 }
5614
5615 #[allow(unused_variables)]
5616 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5617 where
5618 E: serde::de::Error,
5619 {
5620 match value {
5621 "nodes" => Ok(GeneratedField::Nodes),
5622 "entrypointId" | "entrypoint_id" => Ok(GeneratedField::EntrypointId),
5623 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5624 }
5625 }
5626 }
5627 deserializer.deserialize_identifier(GeneratedVisitor)
5628 }
5629 }
5630 struct GeneratedVisitor;
5631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5632 type Value = HnswGraph;
5633
5634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5635 formatter.write_str("struct hummock.HnswGraph")
5636 }
5637
5638 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraph, V::Error>
5639 where
5640 V: serde::de::MapAccess<'de>,
5641 {
5642 let mut nodes__ = None;
5643 let mut entrypoint_id__ = None;
5644 while let Some(k) = map_.next_key()? {
5645 match k {
5646 GeneratedField::Nodes => {
5647 if nodes__.is_some() {
5648 return Err(serde::de::Error::duplicate_field("nodes"));
5649 }
5650 nodes__ = Some(map_.next_value()?);
5651 }
5652 GeneratedField::EntrypointId => {
5653 if entrypoint_id__.is_some() {
5654 return Err(serde::de::Error::duplicate_field("entrypointId"));
5655 }
5656 entrypoint_id__ =
5657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5658 ;
5659 }
5660 }
5661 }
5662 Ok(HnswGraph {
5663 nodes: nodes__.unwrap_or_default(),
5664 entrypoint_id: entrypoint_id__.unwrap_or_default(),
5665 })
5666 }
5667 }
5668 deserializer.deserialize_struct("hummock.HnswGraph", FIELDS, GeneratedVisitor)
5669 }
5670}
5671impl serde::Serialize for hnsw_graph::HnswLevel {
5672 #[allow(deprecated)]
5673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5674 where
5675 S: serde::Serializer,
5676 {
5677 use serde::ser::SerializeStruct;
5678 let mut len = 0;
5679 if !self.neighbors.is_empty() {
5680 len += 1;
5681 }
5682 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswLevel", len)?;
5683 if !self.neighbors.is_empty() {
5684 struct_ser.serialize_field("neighbors", &self.neighbors)?;
5685 }
5686 struct_ser.end()
5687 }
5688}
5689impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswLevel {
5690 #[allow(deprecated)]
5691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5692 where
5693 D: serde::Deserializer<'de>,
5694 {
5695 const FIELDS: &[&str] = &[
5696 "neighbors",
5697 ];
5698
5699 #[allow(clippy::enum_variant_names)]
5700 enum GeneratedField {
5701 Neighbors,
5702 }
5703 impl<'de> serde::Deserialize<'de> for GeneratedField {
5704 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5705 where
5706 D: serde::Deserializer<'de>,
5707 {
5708 struct GeneratedVisitor;
5709
5710 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5711 type Value = GeneratedField;
5712
5713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5714 write!(formatter, "expected one of: {:?}", &FIELDS)
5715 }
5716
5717 #[allow(unused_variables)]
5718 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5719 where
5720 E: serde::de::Error,
5721 {
5722 match value {
5723 "neighbors" => Ok(GeneratedField::Neighbors),
5724 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5725 }
5726 }
5727 }
5728 deserializer.deserialize_identifier(GeneratedVisitor)
5729 }
5730 }
5731 struct GeneratedVisitor;
5732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5733 type Value = hnsw_graph::HnswLevel;
5734
5735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5736 formatter.write_str("struct hummock.HnswGraph.HnswLevel")
5737 }
5738
5739 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswLevel, V::Error>
5740 where
5741 V: serde::de::MapAccess<'de>,
5742 {
5743 let mut neighbors__ = None;
5744 while let Some(k) = map_.next_key()? {
5745 match k {
5746 GeneratedField::Neighbors => {
5747 if neighbors__.is_some() {
5748 return Err(serde::de::Error::duplicate_field("neighbors"));
5749 }
5750 neighbors__ = Some(map_.next_value()?);
5751 }
5752 }
5753 }
5754 Ok(hnsw_graph::HnswLevel {
5755 neighbors: neighbors__.unwrap_or_default(),
5756 })
5757 }
5758 }
5759 deserializer.deserialize_struct("hummock.HnswGraph.HnswLevel", FIELDS, GeneratedVisitor)
5760 }
5761}
5762impl serde::Serialize for hnsw_graph::HnswNeighbor {
5763 #[allow(deprecated)]
5764 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5765 where
5766 S: serde::Serializer,
5767 {
5768 use serde::ser::SerializeStruct;
5769 let mut len = 0;
5770 if self.vector_id != 0 {
5771 len += 1;
5772 }
5773 if self.distance != 0. {
5774 len += 1;
5775 }
5776 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNeighbor", len)?;
5777 if self.vector_id != 0 {
5778 #[allow(clippy::needless_borrow)]
5779 #[allow(clippy::needless_borrows_for_generic_args)]
5780 struct_ser.serialize_field("vectorId", ToString::to_string(&self.vector_id).as_str())?;
5781 }
5782 if self.distance != 0. {
5783 struct_ser.serialize_field("distance", &self.distance)?;
5784 }
5785 struct_ser.end()
5786 }
5787}
5788impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNeighbor {
5789 #[allow(deprecated)]
5790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5791 where
5792 D: serde::Deserializer<'de>,
5793 {
5794 const FIELDS: &[&str] = &[
5795 "vector_id",
5796 "vectorId",
5797 "distance",
5798 ];
5799
5800 #[allow(clippy::enum_variant_names)]
5801 enum GeneratedField {
5802 VectorId,
5803 Distance,
5804 }
5805 impl<'de> serde::Deserialize<'de> for GeneratedField {
5806 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5807 where
5808 D: serde::Deserializer<'de>,
5809 {
5810 struct GeneratedVisitor;
5811
5812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5813 type Value = GeneratedField;
5814
5815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5816 write!(formatter, "expected one of: {:?}", &FIELDS)
5817 }
5818
5819 #[allow(unused_variables)]
5820 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5821 where
5822 E: serde::de::Error,
5823 {
5824 match value {
5825 "vectorId" | "vector_id" => Ok(GeneratedField::VectorId),
5826 "distance" => Ok(GeneratedField::Distance),
5827 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5828 }
5829 }
5830 }
5831 deserializer.deserialize_identifier(GeneratedVisitor)
5832 }
5833 }
5834 struct GeneratedVisitor;
5835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5836 type Value = hnsw_graph::HnswNeighbor;
5837
5838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5839 formatter.write_str("struct hummock.HnswGraph.HnswNeighbor")
5840 }
5841
5842 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNeighbor, V::Error>
5843 where
5844 V: serde::de::MapAccess<'de>,
5845 {
5846 let mut vector_id__ = None;
5847 let mut distance__ = None;
5848 while let Some(k) = map_.next_key()? {
5849 match k {
5850 GeneratedField::VectorId => {
5851 if vector_id__.is_some() {
5852 return Err(serde::de::Error::duplicate_field("vectorId"));
5853 }
5854 vector_id__ =
5855 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5856 ;
5857 }
5858 GeneratedField::Distance => {
5859 if distance__.is_some() {
5860 return Err(serde::de::Error::duplicate_field("distance"));
5861 }
5862 distance__ =
5863 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5864 ;
5865 }
5866 }
5867 }
5868 Ok(hnsw_graph::HnswNeighbor {
5869 vector_id: vector_id__.unwrap_or_default(),
5870 distance: distance__.unwrap_or_default(),
5871 })
5872 }
5873 }
5874 deserializer.deserialize_struct("hummock.HnswGraph.HnswNeighbor", FIELDS, GeneratedVisitor)
5875 }
5876}
5877impl serde::Serialize for hnsw_graph::HnswNode {
5878 #[allow(deprecated)]
5879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5880 where
5881 S: serde::Serializer,
5882 {
5883 use serde::ser::SerializeStruct;
5884 let mut len = 0;
5885 if !self.levels.is_empty() {
5886 len += 1;
5887 }
5888 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNode", len)?;
5889 if !self.levels.is_empty() {
5890 struct_ser.serialize_field("levels", &self.levels)?;
5891 }
5892 struct_ser.end()
5893 }
5894}
5895impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNode {
5896 #[allow(deprecated)]
5897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5898 where
5899 D: serde::Deserializer<'de>,
5900 {
5901 const FIELDS: &[&str] = &[
5902 "levels",
5903 ];
5904
5905 #[allow(clippy::enum_variant_names)]
5906 enum GeneratedField {
5907 Levels,
5908 }
5909 impl<'de> serde::Deserialize<'de> for GeneratedField {
5910 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5911 where
5912 D: serde::Deserializer<'de>,
5913 {
5914 struct GeneratedVisitor;
5915
5916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5917 type Value = GeneratedField;
5918
5919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5920 write!(formatter, "expected one of: {:?}", &FIELDS)
5921 }
5922
5923 #[allow(unused_variables)]
5924 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5925 where
5926 E: serde::de::Error,
5927 {
5928 match value {
5929 "levels" => Ok(GeneratedField::Levels),
5930 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5931 }
5932 }
5933 }
5934 deserializer.deserialize_identifier(GeneratedVisitor)
5935 }
5936 }
5937 struct GeneratedVisitor;
5938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5939 type Value = hnsw_graph::HnswNode;
5940
5941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5942 formatter.write_str("struct hummock.HnswGraph.HnswNode")
5943 }
5944
5945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNode, V::Error>
5946 where
5947 V: serde::de::MapAccess<'de>,
5948 {
5949 let mut levels__ = None;
5950 while let Some(k) = map_.next_key()? {
5951 match k {
5952 GeneratedField::Levels => {
5953 if levels__.is_some() {
5954 return Err(serde::de::Error::duplicate_field("levels"));
5955 }
5956 levels__ = Some(map_.next_value()?);
5957 }
5958 }
5959 }
5960 Ok(hnsw_graph::HnswNode {
5961 levels: levels__.unwrap_or_default(),
5962 })
5963 }
5964 }
5965 deserializer.deserialize_struct("hummock.HnswGraph.HnswNode", FIELDS, GeneratedVisitor)
5966 }
5967}
5968impl serde::Serialize for HnswGraphFileInfo {
5969 #[allow(deprecated)]
5970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5971 where
5972 S: serde::Serializer,
5973 {
5974 use serde::ser::SerializeStruct;
5975 let mut len = 0;
5976 if self.object_id != 0 {
5977 len += 1;
5978 }
5979 if self.file_size != 0 {
5980 len += 1;
5981 }
5982 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraphFileInfo", len)?;
5983 if self.object_id != 0 {
5984 #[allow(clippy::needless_borrow)]
5985 #[allow(clippy::needless_borrows_for_generic_args)]
5986 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
5987 }
5988 if self.file_size != 0 {
5989 #[allow(clippy::needless_borrow)]
5990 #[allow(clippy::needless_borrows_for_generic_args)]
5991 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
5992 }
5993 struct_ser.end()
5994 }
5995}
5996impl<'de> serde::Deserialize<'de> for HnswGraphFileInfo {
5997 #[allow(deprecated)]
5998 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5999 where
6000 D: serde::Deserializer<'de>,
6001 {
6002 const FIELDS: &[&str] = &[
6003 "object_id",
6004 "objectId",
6005 "file_size",
6006 "fileSize",
6007 ];
6008
6009 #[allow(clippy::enum_variant_names)]
6010 enum GeneratedField {
6011 ObjectId,
6012 FileSize,
6013 }
6014 impl<'de> serde::Deserialize<'de> for GeneratedField {
6015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6016 where
6017 D: serde::Deserializer<'de>,
6018 {
6019 struct GeneratedVisitor;
6020
6021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6022 type Value = GeneratedField;
6023
6024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6025 write!(formatter, "expected one of: {:?}", &FIELDS)
6026 }
6027
6028 #[allow(unused_variables)]
6029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6030 where
6031 E: serde::de::Error,
6032 {
6033 match value {
6034 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
6035 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
6036 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6037 }
6038 }
6039 }
6040 deserializer.deserialize_identifier(GeneratedVisitor)
6041 }
6042 }
6043 struct GeneratedVisitor;
6044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6045 type Value = HnswGraphFileInfo;
6046
6047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6048 formatter.write_str("struct hummock.HnswGraphFileInfo")
6049 }
6050
6051 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraphFileInfo, V::Error>
6052 where
6053 V: serde::de::MapAccess<'de>,
6054 {
6055 let mut object_id__ = None;
6056 let mut file_size__ = None;
6057 while let Some(k) = map_.next_key()? {
6058 match k {
6059 GeneratedField::ObjectId => {
6060 if object_id__.is_some() {
6061 return Err(serde::de::Error::duplicate_field("objectId"));
6062 }
6063 object_id__ =
6064 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6065 ;
6066 }
6067 GeneratedField::FileSize => {
6068 if file_size__.is_some() {
6069 return Err(serde::de::Error::duplicate_field("fileSize"));
6070 }
6071 file_size__ =
6072 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6073 ;
6074 }
6075 }
6076 }
6077 Ok(HnswGraphFileInfo {
6078 object_id: object_id__.unwrap_or_default(),
6079 file_size: file_size__.unwrap_or_default(),
6080 })
6081 }
6082 }
6083 deserializer.deserialize_struct("hummock.HnswGraphFileInfo", FIELDS, GeneratedVisitor)
6084 }
6085}
6086impl serde::Serialize for HummockPinnedSnapshot {
6087 #[allow(deprecated)]
6088 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6089 where
6090 S: serde::Serializer,
6091 {
6092 use serde::ser::SerializeStruct;
6093 let mut len = 0;
6094 if self.context_id != 0 {
6095 len += 1;
6096 }
6097 if self.minimal_pinned_snapshot != 0 {
6098 len += 1;
6099 }
6100 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
6101 if self.context_id != 0 {
6102 struct_ser.serialize_field("contextId", &self.context_id)?;
6103 }
6104 if self.minimal_pinned_snapshot != 0 {
6105 #[allow(clippy::needless_borrow)]
6106 #[allow(clippy::needless_borrows_for_generic_args)]
6107 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
6108 }
6109 struct_ser.end()
6110 }
6111}
6112impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
6113 #[allow(deprecated)]
6114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6115 where
6116 D: serde::Deserializer<'de>,
6117 {
6118 const FIELDS: &[&str] = &[
6119 "context_id",
6120 "contextId",
6121 "minimal_pinned_snapshot",
6122 "minimalPinnedSnapshot",
6123 ];
6124
6125 #[allow(clippy::enum_variant_names)]
6126 enum GeneratedField {
6127 ContextId,
6128 MinimalPinnedSnapshot,
6129 }
6130 impl<'de> serde::Deserialize<'de> for GeneratedField {
6131 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6132 where
6133 D: serde::Deserializer<'de>,
6134 {
6135 struct GeneratedVisitor;
6136
6137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6138 type Value = GeneratedField;
6139
6140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6141 write!(formatter, "expected one of: {:?}", &FIELDS)
6142 }
6143
6144 #[allow(unused_variables)]
6145 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6146 where
6147 E: serde::de::Error,
6148 {
6149 match value {
6150 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6151 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
6152 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6153 }
6154 }
6155 }
6156 deserializer.deserialize_identifier(GeneratedVisitor)
6157 }
6158 }
6159 struct GeneratedVisitor;
6160 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6161 type Value = HummockPinnedSnapshot;
6162
6163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6164 formatter.write_str("struct hummock.HummockPinnedSnapshot")
6165 }
6166
6167 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
6168 where
6169 V: serde::de::MapAccess<'de>,
6170 {
6171 let mut context_id__ = None;
6172 let mut minimal_pinned_snapshot__ = None;
6173 while let Some(k) = map_.next_key()? {
6174 match k {
6175 GeneratedField::ContextId => {
6176 if context_id__.is_some() {
6177 return Err(serde::de::Error::duplicate_field("contextId"));
6178 }
6179 context_id__ =
6180 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6181 ;
6182 }
6183 GeneratedField::MinimalPinnedSnapshot => {
6184 if minimal_pinned_snapshot__.is_some() {
6185 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
6186 }
6187 minimal_pinned_snapshot__ =
6188 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6189 ;
6190 }
6191 }
6192 }
6193 Ok(HummockPinnedSnapshot {
6194 context_id: context_id__.unwrap_or_default(),
6195 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
6196 })
6197 }
6198 }
6199 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
6200 }
6201}
6202impl serde::Serialize for HummockPinnedVersion {
6203 #[allow(deprecated)]
6204 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6205 where
6206 S: serde::Serializer,
6207 {
6208 use serde::ser::SerializeStruct;
6209 let mut len = 0;
6210 if self.context_id != 0 {
6211 len += 1;
6212 }
6213 if self.min_pinned_id != 0 {
6214 len += 1;
6215 }
6216 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
6217 if self.context_id != 0 {
6218 struct_ser.serialize_field("contextId", &self.context_id)?;
6219 }
6220 if self.min_pinned_id != 0 {
6221 #[allow(clippy::needless_borrow)]
6222 #[allow(clippy::needless_borrows_for_generic_args)]
6223 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
6224 }
6225 struct_ser.end()
6226 }
6227}
6228impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
6229 #[allow(deprecated)]
6230 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6231 where
6232 D: serde::Deserializer<'de>,
6233 {
6234 const FIELDS: &[&str] = &[
6235 "context_id",
6236 "contextId",
6237 "min_pinned_id",
6238 "minPinnedId",
6239 ];
6240
6241 #[allow(clippy::enum_variant_names)]
6242 enum GeneratedField {
6243 ContextId,
6244 MinPinnedId,
6245 }
6246 impl<'de> serde::Deserialize<'de> for GeneratedField {
6247 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6248 where
6249 D: serde::Deserializer<'de>,
6250 {
6251 struct GeneratedVisitor;
6252
6253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6254 type Value = GeneratedField;
6255
6256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6257 write!(formatter, "expected one of: {:?}", &FIELDS)
6258 }
6259
6260 #[allow(unused_variables)]
6261 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6262 where
6263 E: serde::de::Error,
6264 {
6265 match value {
6266 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6267 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
6268 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6269 }
6270 }
6271 }
6272 deserializer.deserialize_identifier(GeneratedVisitor)
6273 }
6274 }
6275 struct GeneratedVisitor;
6276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6277 type Value = HummockPinnedVersion;
6278
6279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6280 formatter.write_str("struct hummock.HummockPinnedVersion")
6281 }
6282
6283 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
6284 where
6285 V: serde::de::MapAccess<'de>,
6286 {
6287 let mut context_id__ = None;
6288 let mut min_pinned_id__ = None;
6289 while let Some(k) = map_.next_key()? {
6290 match k {
6291 GeneratedField::ContextId => {
6292 if context_id__.is_some() {
6293 return Err(serde::de::Error::duplicate_field("contextId"));
6294 }
6295 context_id__ =
6296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6297 ;
6298 }
6299 GeneratedField::MinPinnedId => {
6300 if min_pinned_id__.is_some() {
6301 return Err(serde::de::Error::duplicate_field("minPinnedId"));
6302 }
6303 min_pinned_id__ =
6304 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6305 ;
6306 }
6307 }
6308 }
6309 Ok(HummockPinnedVersion {
6310 context_id: context_id__.unwrap_or_default(),
6311 min_pinned_id: min_pinned_id__.unwrap_or_default(),
6312 })
6313 }
6314 }
6315 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
6316 }
6317}
6318impl serde::Serialize for HummockVersion {
6319 #[allow(deprecated)]
6320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6321 where
6322 S: serde::Serializer,
6323 {
6324 use serde::ser::SerializeStruct;
6325 let mut len = 0;
6326 if self.id != 0 {
6327 len += 1;
6328 }
6329 if !self.levels.is_empty() {
6330 len += 1;
6331 }
6332 if self.max_committed_epoch != 0 {
6333 len += 1;
6334 }
6335 if !self.table_watermarks.is_empty() {
6336 len += 1;
6337 }
6338 if !self.table_change_logs.is_empty() {
6339 len += 1;
6340 }
6341 if !self.state_table_info.is_empty() {
6342 len += 1;
6343 }
6344 if !self.vector_indexes.is_empty() {
6345 len += 1;
6346 }
6347 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
6348 if self.id != 0 {
6349 #[allow(clippy::needless_borrow)]
6350 #[allow(clippy::needless_borrows_for_generic_args)]
6351 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6352 }
6353 if !self.levels.is_empty() {
6354 struct_ser.serialize_field("levels", &self.levels)?;
6355 }
6356 if self.max_committed_epoch != 0 {
6357 #[allow(clippy::needless_borrow)]
6358 #[allow(clippy::needless_borrows_for_generic_args)]
6359 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6360 }
6361 if !self.table_watermarks.is_empty() {
6362 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
6363 }
6364 if !self.table_change_logs.is_empty() {
6365 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
6366 }
6367 if !self.state_table_info.is_empty() {
6368 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
6369 }
6370 if !self.vector_indexes.is_empty() {
6371 struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
6372 }
6373 struct_ser.end()
6374 }
6375}
6376impl<'de> serde::Deserialize<'de> for HummockVersion {
6377 #[allow(deprecated)]
6378 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6379 where
6380 D: serde::Deserializer<'de>,
6381 {
6382 const FIELDS: &[&str] = &[
6383 "id",
6384 "levels",
6385 "max_committed_epoch",
6386 "maxCommittedEpoch",
6387 "table_watermarks",
6388 "tableWatermarks",
6389 "table_change_logs",
6390 "tableChangeLogs",
6391 "state_table_info",
6392 "stateTableInfo",
6393 "vector_indexes",
6394 "vectorIndexes",
6395 ];
6396
6397 #[allow(clippy::enum_variant_names)]
6398 enum GeneratedField {
6399 Id,
6400 Levels,
6401 MaxCommittedEpoch,
6402 TableWatermarks,
6403 TableChangeLogs,
6404 StateTableInfo,
6405 VectorIndexes,
6406 }
6407 impl<'de> serde::Deserialize<'de> for GeneratedField {
6408 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6409 where
6410 D: serde::Deserializer<'de>,
6411 {
6412 struct GeneratedVisitor;
6413
6414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6415 type Value = GeneratedField;
6416
6417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6418 write!(formatter, "expected one of: {:?}", &FIELDS)
6419 }
6420
6421 #[allow(unused_variables)]
6422 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6423 where
6424 E: serde::de::Error,
6425 {
6426 match value {
6427 "id" => Ok(GeneratedField::Id),
6428 "levels" => Ok(GeneratedField::Levels),
6429 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6430 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
6431 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
6432 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
6433 "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
6434 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6435 }
6436 }
6437 }
6438 deserializer.deserialize_identifier(GeneratedVisitor)
6439 }
6440 }
6441 struct GeneratedVisitor;
6442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6443 type Value = HummockVersion;
6444
6445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6446 formatter.write_str("struct hummock.HummockVersion")
6447 }
6448
6449 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
6450 where
6451 V: serde::de::MapAccess<'de>,
6452 {
6453 let mut id__ = None;
6454 let mut levels__ = None;
6455 let mut max_committed_epoch__ = None;
6456 let mut table_watermarks__ = None;
6457 let mut table_change_logs__ = None;
6458 let mut state_table_info__ = None;
6459 let mut vector_indexes__ = None;
6460 while let Some(k) = map_.next_key()? {
6461 match k {
6462 GeneratedField::Id => {
6463 if id__.is_some() {
6464 return Err(serde::de::Error::duplicate_field("id"));
6465 }
6466 id__ =
6467 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6468 ;
6469 }
6470 GeneratedField::Levels => {
6471 if levels__.is_some() {
6472 return Err(serde::de::Error::duplicate_field("levels"));
6473 }
6474 levels__ = Some(
6475 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6476 .into_iter().map(|(k,v)| (k.0, v)).collect()
6477 );
6478 }
6479 GeneratedField::MaxCommittedEpoch => {
6480 if max_committed_epoch__.is_some() {
6481 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
6482 }
6483 max_committed_epoch__ =
6484 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6485 ;
6486 }
6487 GeneratedField::TableWatermarks => {
6488 if table_watermarks__.is_some() {
6489 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
6490 }
6491 table_watermarks__ = Some(
6492 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6493 .into_iter().map(|(k,v)| (k.0, v)).collect()
6494 );
6495 }
6496 GeneratedField::TableChangeLogs => {
6497 if table_change_logs__.is_some() {
6498 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
6499 }
6500 table_change_logs__ = Some(
6501 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6502 .into_iter().map(|(k,v)| (k.0, v)).collect()
6503 );
6504 }
6505 GeneratedField::StateTableInfo => {
6506 if state_table_info__.is_some() {
6507 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
6508 }
6509 state_table_info__ = Some(
6510 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6511 .into_iter().map(|(k,v)| (k.0, v)).collect()
6512 );
6513 }
6514 GeneratedField::VectorIndexes => {
6515 if vector_indexes__.is_some() {
6516 return Err(serde::de::Error::duplicate_field("vectorIndexes"));
6517 }
6518 vector_indexes__ = Some(
6519 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6520 .into_iter().map(|(k,v)| (k.0, v)).collect()
6521 );
6522 }
6523 }
6524 }
6525 Ok(HummockVersion {
6526 id: id__.unwrap_or_default(),
6527 levels: levels__.unwrap_or_default(),
6528 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
6529 table_watermarks: table_watermarks__.unwrap_or_default(),
6530 table_change_logs: table_change_logs__.unwrap_or_default(),
6531 state_table_info: state_table_info__.unwrap_or_default(),
6532 vector_indexes: vector_indexes__.unwrap_or_default(),
6533 })
6534 }
6535 }
6536 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
6537 }
6538}
6539impl serde::Serialize for hummock_version::Levels {
6540 #[allow(deprecated)]
6541 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6542 where
6543 S: serde::Serializer,
6544 {
6545 use serde::ser::SerializeStruct;
6546 let mut len = 0;
6547 if !self.levels.is_empty() {
6548 len += 1;
6549 }
6550 if self.l0.is_some() {
6551 len += 1;
6552 }
6553 if self.group_id != 0 {
6554 len += 1;
6555 }
6556 if self.parent_group_id != 0 {
6557 len += 1;
6558 }
6559 if !self.member_table_ids.is_empty() {
6560 len += 1;
6561 }
6562 if self.compaction_group_version_id != 0 {
6563 len += 1;
6564 }
6565 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
6566 if !self.levels.is_empty() {
6567 struct_ser.serialize_field("levels", &self.levels)?;
6568 }
6569 if let Some(v) = self.l0.as_ref() {
6570 struct_ser.serialize_field("l0", v)?;
6571 }
6572 if self.group_id != 0 {
6573 #[allow(clippy::needless_borrow)]
6574 #[allow(clippy::needless_borrows_for_generic_args)]
6575 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
6576 }
6577 if self.parent_group_id != 0 {
6578 #[allow(clippy::needless_borrow)]
6579 #[allow(clippy::needless_borrows_for_generic_args)]
6580 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
6581 }
6582 if !self.member_table_ids.is_empty() {
6583 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
6584 }
6585 if self.compaction_group_version_id != 0 {
6586 #[allow(clippy::needless_borrow)]
6587 #[allow(clippy::needless_borrows_for_generic_args)]
6588 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
6589 }
6590 struct_ser.end()
6591 }
6592}
6593impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
6594 #[allow(deprecated)]
6595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6596 where
6597 D: serde::Deserializer<'de>,
6598 {
6599 const FIELDS: &[&str] = &[
6600 "levels",
6601 "l0",
6602 "group_id",
6603 "groupId",
6604 "parent_group_id",
6605 "parentGroupId",
6606 "member_table_ids",
6607 "memberTableIds",
6608 "compaction_group_version_id",
6609 "compactionGroupVersionId",
6610 ];
6611
6612 #[allow(clippy::enum_variant_names)]
6613 enum GeneratedField {
6614 Levels,
6615 L0,
6616 GroupId,
6617 ParentGroupId,
6618 MemberTableIds,
6619 CompactionGroupVersionId,
6620 }
6621 impl<'de> serde::Deserialize<'de> for GeneratedField {
6622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6623 where
6624 D: serde::Deserializer<'de>,
6625 {
6626 struct GeneratedVisitor;
6627
6628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6629 type Value = GeneratedField;
6630
6631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6632 write!(formatter, "expected one of: {:?}", &FIELDS)
6633 }
6634
6635 #[allow(unused_variables)]
6636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6637 where
6638 E: serde::de::Error,
6639 {
6640 match value {
6641 "levels" => Ok(GeneratedField::Levels),
6642 "l0" => Ok(GeneratedField::L0),
6643 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
6644 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
6645 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
6646 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
6647 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6648 }
6649 }
6650 }
6651 deserializer.deserialize_identifier(GeneratedVisitor)
6652 }
6653 }
6654 struct GeneratedVisitor;
6655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6656 type Value = hummock_version::Levels;
6657
6658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6659 formatter.write_str("struct hummock.HummockVersion.Levels")
6660 }
6661
6662 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
6663 where
6664 V: serde::de::MapAccess<'de>,
6665 {
6666 let mut levels__ = None;
6667 let mut l0__ = None;
6668 let mut group_id__ = None;
6669 let mut parent_group_id__ = None;
6670 let mut member_table_ids__ = None;
6671 let mut compaction_group_version_id__ = None;
6672 while let Some(k) = map_.next_key()? {
6673 match k {
6674 GeneratedField::Levels => {
6675 if levels__.is_some() {
6676 return Err(serde::de::Error::duplicate_field("levels"));
6677 }
6678 levels__ = Some(map_.next_value()?);
6679 }
6680 GeneratedField::L0 => {
6681 if l0__.is_some() {
6682 return Err(serde::de::Error::duplicate_field("l0"));
6683 }
6684 l0__ = map_.next_value()?;
6685 }
6686 GeneratedField::GroupId => {
6687 if group_id__.is_some() {
6688 return Err(serde::de::Error::duplicate_field("groupId"));
6689 }
6690 group_id__ =
6691 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6692 ;
6693 }
6694 GeneratedField::ParentGroupId => {
6695 if parent_group_id__.is_some() {
6696 return Err(serde::de::Error::duplicate_field("parentGroupId"));
6697 }
6698 parent_group_id__ =
6699 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6700 ;
6701 }
6702 GeneratedField::MemberTableIds => {
6703 if member_table_ids__.is_some() {
6704 return Err(serde::de::Error::duplicate_field("memberTableIds"));
6705 }
6706 member_table_ids__ =
6707 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6708 .into_iter().map(|x| x.0).collect())
6709 ;
6710 }
6711 GeneratedField::CompactionGroupVersionId => {
6712 if compaction_group_version_id__.is_some() {
6713 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
6714 }
6715 compaction_group_version_id__ =
6716 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6717 ;
6718 }
6719 }
6720 }
6721 Ok(hummock_version::Levels {
6722 levels: levels__.unwrap_or_default(),
6723 l0: l0__,
6724 group_id: group_id__.unwrap_or_default(),
6725 parent_group_id: parent_group_id__.unwrap_or_default(),
6726 member_table_ids: member_table_ids__.unwrap_or_default(),
6727 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
6728 })
6729 }
6730 }
6731 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
6732 }
6733}
6734impl serde::Serialize for HummockVersionArchive {
6735 #[allow(deprecated)]
6736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6737 where
6738 S: serde::Serializer,
6739 {
6740 use serde::ser::SerializeStruct;
6741 let mut len = 0;
6742 if self.version.is_some() {
6743 len += 1;
6744 }
6745 if !self.version_deltas.is_empty() {
6746 len += 1;
6747 }
6748 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
6749 if let Some(v) = self.version.as_ref() {
6750 struct_ser.serialize_field("version", v)?;
6751 }
6752 if !self.version_deltas.is_empty() {
6753 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6754 }
6755 struct_ser.end()
6756 }
6757}
6758impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
6759 #[allow(deprecated)]
6760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6761 where
6762 D: serde::Deserializer<'de>,
6763 {
6764 const FIELDS: &[&str] = &[
6765 "version",
6766 "version_deltas",
6767 "versionDeltas",
6768 ];
6769
6770 #[allow(clippy::enum_variant_names)]
6771 enum GeneratedField {
6772 Version,
6773 VersionDeltas,
6774 }
6775 impl<'de> serde::Deserialize<'de> for GeneratedField {
6776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6777 where
6778 D: serde::Deserializer<'de>,
6779 {
6780 struct GeneratedVisitor;
6781
6782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6783 type Value = GeneratedField;
6784
6785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6786 write!(formatter, "expected one of: {:?}", &FIELDS)
6787 }
6788
6789 #[allow(unused_variables)]
6790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6791 where
6792 E: serde::de::Error,
6793 {
6794 match value {
6795 "version" => Ok(GeneratedField::Version),
6796 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6797 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6798 }
6799 }
6800 }
6801 deserializer.deserialize_identifier(GeneratedVisitor)
6802 }
6803 }
6804 struct GeneratedVisitor;
6805 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6806 type Value = HummockVersionArchive;
6807
6808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6809 formatter.write_str("struct hummock.HummockVersionArchive")
6810 }
6811
6812 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
6813 where
6814 V: serde::de::MapAccess<'de>,
6815 {
6816 let mut version__ = None;
6817 let mut version_deltas__ = None;
6818 while let Some(k) = map_.next_key()? {
6819 match k {
6820 GeneratedField::Version => {
6821 if version__.is_some() {
6822 return Err(serde::de::Error::duplicate_field("version"));
6823 }
6824 version__ = map_.next_value()?;
6825 }
6826 GeneratedField::VersionDeltas => {
6827 if version_deltas__.is_some() {
6828 return Err(serde::de::Error::duplicate_field("versionDeltas"));
6829 }
6830 version_deltas__ = Some(map_.next_value()?);
6831 }
6832 }
6833 }
6834 Ok(HummockVersionArchive {
6835 version: version__,
6836 version_deltas: version_deltas__.unwrap_or_default(),
6837 })
6838 }
6839 }
6840 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
6841 }
6842}
6843impl serde::Serialize for HummockVersionCheckpoint {
6844 #[allow(deprecated)]
6845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6846 where
6847 S: serde::Serializer,
6848 {
6849 use serde::ser::SerializeStruct;
6850 let mut len = 0;
6851 if self.version.is_some() {
6852 len += 1;
6853 }
6854 if !self.stale_objects.is_empty() {
6855 len += 1;
6856 }
6857 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
6858 if let Some(v) = self.version.as_ref() {
6859 struct_ser.serialize_field("version", v)?;
6860 }
6861 if !self.stale_objects.is_empty() {
6862 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
6863 }
6864 struct_ser.end()
6865 }
6866}
6867impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
6868 #[allow(deprecated)]
6869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6870 where
6871 D: serde::Deserializer<'de>,
6872 {
6873 const FIELDS: &[&str] = &[
6874 "version",
6875 "stale_objects",
6876 "staleObjects",
6877 ];
6878
6879 #[allow(clippy::enum_variant_names)]
6880 enum GeneratedField {
6881 Version,
6882 StaleObjects,
6883 }
6884 impl<'de> serde::Deserialize<'de> for GeneratedField {
6885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6886 where
6887 D: serde::Deserializer<'de>,
6888 {
6889 struct GeneratedVisitor;
6890
6891 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6892 type Value = GeneratedField;
6893
6894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6895 write!(formatter, "expected one of: {:?}", &FIELDS)
6896 }
6897
6898 #[allow(unused_variables)]
6899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6900 where
6901 E: serde::de::Error,
6902 {
6903 match value {
6904 "version" => Ok(GeneratedField::Version),
6905 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
6906 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6907 }
6908 }
6909 }
6910 deserializer.deserialize_identifier(GeneratedVisitor)
6911 }
6912 }
6913 struct GeneratedVisitor;
6914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6915 type Value = HummockVersionCheckpoint;
6916
6917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6918 formatter.write_str("struct hummock.HummockVersionCheckpoint")
6919 }
6920
6921 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
6922 where
6923 V: serde::de::MapAccess<'de>,
6924 {
6925 let mut version__ = None;
6926 let mut stale_objects__ = None;
6927 while let Some(k) = map_.next_key()? {
6928 match k {
6929 GeneratedField::Version => {
6930 if version__.is_some() {
6931 return Err(serde::de::Error::duplicate_field("version"));
6932 }
6933 version__ = map_.next_value()?;
6934 }
6935 GeneratedField::StaleObjects => {
6936 if stale_objects__.is_some() {
6937 return Err(serde::de::Error::duplicate_field("staleObjects"));
6938 }
6939 stale_objects__ = Some(
6940 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6941 .into_iter().map(|(k,v)| (k.0, v)).collect()
6942 );
6943 }
6944 }
6945 }
6946 Ok(HummockVersionCheckpoint {
6947 version: version__,
6948 stale_objects: stale_objects__.unwrap_or_default(),
6949 })
6950 }
6951 }
6952 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
6953 }
6954}
6955impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
6956 #[allow(deprecated)]
6957 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6958 where
6959 S: serde::Serializer,
6960 {
6961 use serde::ser::SerializeStruct;
6962 let mut len = 0;
6963 if !self.id.is_empty() {
6964 len += 1;
6965 }
6966 if self.total_file_size != 0 {
6967 len += 1;
6968 }
6969 if !self.vector_files.is_empty() {
6970 len += 1;
6971 }
6972 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
6973 if !self.id.is_empty() {
6974 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
6975 }
6976 if self.total_file_size != 0 {
6977 #[allow(clippy::needless_borrow)]
6978 #[allow(clippy::needless_borrows_for_generic_args)]
6979 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
6980 }
6981 if !self.vector_files.is_empty() {
6982 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
6983 }
6984 struct_ser.end()
6985 }
6986}
6987impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
6988 #[allow(deprecated)]
6989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6990 where
6991 D: serde::Deserializer<'de>,
6992 {
6993 const FIELDS: &[&str] = &[
6994 "id",
6995 "total_file_size",
6996 "totalFileSize",
6997 "vector_files",
6998 "vectorFiles",
6999 ];
7000
7001 #[allow(clippy::enum_variant_names)]
7002 enum GeneratedField {
7003 Id,
7004 TotalFileSize,
7005 VectorFiles,
7006 }
7007 impl<'de> serde::Deserialize<'de> for GeneratedField {
7008 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7009 where
7010 D: serde::Deserializer<'de>,
7011 {
7012 struct GeneratedVisitor;
7013
7014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7015 type Value = GeneratedField;
7016
7017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7018 write!(formatter, "expected one of: {:?}", &FIELDS)
7019 }
7020
7021 #[allow(unused_variables)]
7022 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7023 where
7024 E: serde::de::Error,
7025 {
7026 match value {
7027 "id" => Ok(GeneratedField::Id),
7028 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7029 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
7030 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7031 }
7032 }
7033 }
7034 deserializer.deserialize_identifier(GeneratedVisitor)
7035 }
7036 }
7037 struct GeneratedVisitor;
7038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7039 type Value = hummock_version_checkpoint::StaleObjects;
7040
7041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7042 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
7043 }
7044
7045 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
7046 where
7047 V: serde::de::MapAccess<'de>,
7048 {
7049 let mut id__ = None;
7050 let mut total_file_size__ = None;
7051 let mut vector_files__ = None;
7052 while let Some(k) = map_.next_key()? {
7053 match k {
7054 GeneratedField::Id => {
7055 if id__.is_some() {
7056 return Err(serde::de::Error::duplicate_field("id"));
7057 }
7058 id__ =
7059 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7060 .into_iter().map(|x| x.0).collect())
7061 ;
7062 }
7063 GeneratedField::TotalFileSize => {
7064 if total_file_size__.is_some() {
7065 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7066 }
7067 total_file_size__ =
7068 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7069 ;
7070 }
7071 GeneratedField::VectorFiles => {
7072 if vector_files__.is_some() {
7073 return Err(serde::de::Error::duplicate_field("vectorFiles"));
7074 }
7075 vector_files__ = Some(map_.next_value()?);
7076 }
7077 }
7078 }
7079 Ok(hummock_version_checkpoint::StaleObjects {
7080 id: id__.unwrap_or_default(),
7081 total_file_size: total_file_size__.unwrap_or_default(),
7082 vector_files: vector_files__.unwrap_or_default(),
7083 })
7084 }
7085 }
7086 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
7087 }
7088}
7089impl serde::Serialize for HummockVersionDelta {
7090 #[allow(deprecated)]
7091 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7092 where
7093 S: serde::Serializer,
7094 {
7095 use serde::ser::SerializeStruct;
7096 let mut len = 0;
7097 if self.id != 0 {
7098 len += 1;
7099 }
7100 if self.prev_id != 0 {
7101 len += 1;
7102 }
7103 if !self.group_deltas.is_empty() {
7104 len += 1;
7105 }
7106 if self.max_committed_epoch != 0 {
7107 len += 1;
7108 }
7109 if self.trivial_move {
7110 len += 1;
7111 }
7112 if !self.new_table_watermarks.is_empty() {
7113 len += 1;
7114 }
7115 if !self.removed_table_ids.is_empty() {
7116 len += 1;
7117 }
7118 if !self.change_log_delta.is_empty() {
7119 len += 1;
7120 }
7121 if !self.state_table_info_delta.is_empty() {
7122 len += 1;
7123 }
7124 if !self.vector_index_delta.is_empty() {
7125 len += 1;
7126 }
7127 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
7128 if self.id != 0 {
7129 #[allow(clippy::needless_borrow)]
7130 #[allow(clippy::needless_borrows_for_generic_args)]
7131 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7132 }
7133 if self.prev_id != 0 {
7134 #[allow(clippy::needless_borrow)]
7135 #[allow(clippy::needless_borrows_for_generic_args)]
7136 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
7137 }
7138 if !self.group_deltas.is_empty() {
7139 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7140 }
7141 if self.max_committed_epoch != 0 {
7142 #[allow(clippy::needless_borrow)]
7143 #[allow(clippy::needless_borrows_for_generic_args)]
7144 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
7145 }
7146 if self.trivial_move {
7147 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
7148 }
7149 if !self.new_table_watermarks.is_empty() {
7150 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
7151 }
7152 if !self.removed_table_ids.is_empty() {
7153 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
7154 }
7155 if !self.change_log_delta.is_empty() {
7156 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
7157 }
7158 if !self.state_table_info_delta.is_empty() {
7159 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
7160 }
7161 if !self.vector_index_delta.is_empty() {
7162 struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
7163 }
7164 struct_ser.end()
7165 }
7166}
7167impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
7168 #[allow(deprecated)]
7169 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7170 where
7171 D: serde::Deserializer<'de>,
7172 {
7173 const FIELDS: &[&str] = &[
7174 "id",
7175 "prev_id",
7176 "prevId",
7177 "group_deltas",
7178 "groupDeltas",
7179 "max_committed_epoch",
7180 "maxCommittedEpoch",
7181 "trivial_move",
7182 "trivialMove",
7183 "new_table_watermarks",
7184 "newTableWatermarks",
7185 "removed_table_ids",
7186 "removedTableIds",
7187 "change_log_delta",
7188 "changeLogDelta",
7189 "state_table_info_delta",
7190 "stateTableInfoDelta",
7191 "vector_index_delta",
7192 "vectorIndexDelta",
7193 ];
7194
7195 #[allow(clippy::enum_variant_names)]
7196 enum GeneratedField {
7197 Id,
7198 PrevId,
7199 GroupDeltas,
7200 MaxCommittedEpoch,
7201 TrivialMove,
7202 NewTableWatermarks,
7203 RemovedTableIds,
7204 ChangeLogDelta,
7205 StateTableInfoDelta,
7206 VectorIndexDelta,
7207 }
7208 impl<'de> serde::Deserialize<'de> for GeneratedField {
7209 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7210 where
7211 D: serde::Deserializer<'de>,
7212 {
7213 struct GeneratedVisitor;
7214
7215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7216 type Value = GeneratedField;
7217
7218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7219 write!(formatter, "expected one of: {:?}", &FIELDS)
7220 }
7221
7222 #[allow(unused_variables)]
7223 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7224 where
7225 E: serde::de::Error,
7226 {
7227 match value {
7228 "id" => Ok(GeneratedField::Id),
7229 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
7230 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
7231 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
7232 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
7233 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
7234 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7235 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
7236 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
7237 "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
7238 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7239 }
7240 }
7241 }
7242 deserializer.deserialize_identifier(GeneratedVisitor)
7243 }
7244 }
7245 struct GeneratedVisitor;
7246 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7247 type Value = HummockVersionDelta;
7248
7249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7250 formatter.write_str("struct hummock.HummockVersionDelta")
7251 }
7252
7253 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
7254 where
7255 V: serde::de::MapAccess<'de>,
7256 {
7257 let mut id__ = None;
7258 let mut prev_id__ = None;
7259 let mut group_deltas__ = None;
7260 let mut max_committed_epoch__ = None;
7261 let mut trivial_move__ = None;
7262 let mut new_table_watermarks__ = None;
7263 let mut removed_table_ids__ = None;
7264 let mut change_log_delta__ = None;
7265 let mut state_table_info_delta__ = None;
7266 let mut vector_index_delta__ = None;
7267 while let Some(k) = map_.next_key()? {
7268 match k {
7269 GeneratedField::Id => {
7270 if id__.is_some() {
7271 return Err(serde::de::Error::duplicate_field("id"));
7272 }
7273 id__ =
7274 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7275 ;
7276 }
7277 GeneratedField::PrevId => {
7278 if prev_id__.is_some() {
7279 return Err(serde::de::Error::duplicate_field("prevId"));
7280 }
7281 prev_id__ =
7282 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7283 ;
7284 }
7285 GeneratedField::GroupDeltas => {
7286 if group_deltas__.is_some() {
7287 return Err(serde::de::Error::duplicate_field("groupDeltas"));
7288 }
7289 group_deltas__ = Some(
7290 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7291 .into_iter().map(|(k,v)| (k.0, v)).collect()
7292 );
7293 }
7294 GeneratedField::MaxCommittedEpoch => {
7295 if max_committed_epoch__.is_some() {
7296 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
7297 }
7298 max_committed_epoch__ =
7299 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7300 ;
7301 }
7302 GeneratedField::TrivialMove => {
7303 if trivial_move__.is_some() {
7304 return Err(serde::de::Error::duplicate_field("trivialMove"));
7305 }
7306 trivial_move__ = Some(map_.next_value()?);
7307 }
7308 GeneratedField::NewTableWatermarks => {
7309 if new_table_watermarks__.is_some() {
7310 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
7311 }
7312 new_table_watermarks__ = Some(
7313 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7314 .into_iter().map(|(k,v)| (k.0, v)).collect()
7315 );
7316 }
7317 GeneratedField::RemovedTableIds => {
7318 if removed_table_ids__.is_some() {
7319 return Err(serde::de::Error::duplicate_field("removedTableIds"));
7320 }
7321 removed_table_ids__ =
7322 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7323 .into_iter().map(|x| x.0).collect())
7324 ;
7325 }
7326 GeneratedField::ChangeLogDelta => {
7327 if change_log_delta__.is_some() {
7328 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
7329 }
7330 change_log_delta__ = Some(
7331 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7332 .into_iter().map(|(k,v)| (k.0, v)).collect()
7333 );
7334 }
7335 GeneratedField::StateTableInfoDelta => {
7336 if state_table_info_delta__.is_some() {
7337 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
7338 }
7339 state_table_info_delta__ = Some(
7340 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7341 .into_iter().map(|(k,v)| (k.0, v)).collect()
7342 );
7343 }
7344 GeneratedField::VectorIndexDelta => {
7345 if vector_index_delta__.is_some() {
7346 return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
7347 }
7348 vector_index_delta__ = Some(
7349 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7350 .into_iter().map(|(k,v)| (k.0, v)).collect()
7351 );
7352 }
7353 }
7354 }
7355 Ok(HummockVersionDelta {
7356 id: id__.unwrap_or_default(),
7357 prev_id: prev_id__.unwrap_or_default(),
7358 group_deltas: group_deltas__.unwrap_or_default(),
7359 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
7360 trivial_move: trivial_move__.unwrap_or_default(),
7361 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
7362 removed_table_ids: removed_table_ids__.unwrap_or_default(),
7363 change_log_delta: change_log_delta__.unwrap_or_default(),
7364 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
7365 vector_index_delta: vector_index_delta__.unwrap_or_default(),
7366 })
7367 }
7368 }
7369 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
7370 }
7371}
7372impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
7373 #[allow(deprecated)]
7374 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7375 where
7376 S: serde::Serializer,
7377 {
7378 use serde::ser::SerializeStruct;
7379 let mut len = 0;
7380 if self.new_log.is_some() {
7381 len += 1;
7382 }
7383 if self.truncate_epoch != 0 {
7384 len += 1;
7385 }
7386 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
7387 if let Some(v) = self.new_log.as_ref() {
7388 struct_ser.serialize_field("newLog", v)?;
7389 }
7390 if self.truncate_epoch != 0 {
7391 #[allow(clippy::needless_borrow)]
7392 #[allow(clippy::needless_borrows_for_generic_args)]
7393 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
7394 }
7395 struct_ser.end()
7396 }
7397}
7398impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
7399 #[allow(deprecated)]
7400 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7401 where
7402 D: serde::Deserializer<'de>,
7403 {
7404 const FIELDS: &[&str] = &[
7405 "new_log",
7406 "newLog",
7407 "truncate_epoch",
7408 "truncateEpoch",
7409 ];
7410
7411 #[allow(clippy::enum_variant_names)]
7412 enum GeneratedField {
7413 NewLog,
7414 TruncateEpoch,
7415 }
7416 impl<'de> serde::Deserialize<'de> for GeneratedField {
7417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7418 where
7419 D: serde::Deserializer<'de>,
7420 {
7421 struct GeneratedVisitor;
7422
7423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7424 type Value = GeneratedField;
7425
7426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7427 write!(formatter, "expected one of: {:?}", &FIELDS)
7428 }
7429
7430 #[allow(unused_variables)]
7431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7432 where
7433 E: serde::de::Error,
7434 {
7435 match value {
7436 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
7437 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
7438 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7439 }
7440 }
7441 }
7442 deserializer.deserialize_identifier(GeneratedVisitor)
7443 }
7444 }
7445 struct GeneratedVisitor;
7446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7447 type Value = hummock_version_delta::ChangeLogDelta;
7448
7449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7450 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
7451 }
7452
7453 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
7454 where
7455 V: serde::de::MapAccess<'de>,
7456 {
7457 let mut new_log__ = None;
7458 let mut truncate_epoch__ = None;
7459 while let Some(k) = map_.next_key()? {
7460 match k {
7461 GeneratedField::NewLog => {
7462 if new_log__.is_some() {
7463 return Err(serde::de::Error::duplicate_field("newLog"));
7464 }
7465 new_log__ = map_.next_value()?;
7466 }
7467 GeneratedField::TruncateEpoch => {
7468 if truncate_epoch__.is_some() {
7469 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
7470 }
7471 truncate_epoch__ =
7472 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7473 ;
7474 }
7475 }
7476 }
7477 Ok(hummock_version_delta::ChangeLogDelta {
7478 new_log: new_log__,
7479 truncate_epoch: truncate_epoch__.unwrap_or_default(),
7480 })
7481 }
7482 }
7483 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
7484 }
7485}
7486impl serde::Serialize for hummock_version_delta::GroupDeltas {
7487 #[allow(deprecated)]
7488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7489 where
7490 S: serde::Serializer,
7491 {
7492 use serde::ser::SerializeStruct;
7493 let mut len = 0;
7494 if !self.group_deltas.is_empty() {
7495 len += 1;
7496 }
7497 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
7498 if !self.group_deltas.is_empty() {
7499 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7500 }
7501 struct_ser.end()
7502 }
7503}
7504impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
7505 #[allow(deprecated)]
7506 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7507 where
7508 D: serde::Deserializer<'de>,
7509 {
7510 const FIELDS: &[&str] = &[
7511 "group_deltas",
7512 "groupDeltas",
7513 ];
7514
7515 #[allow(clippy::enum_variant_names)]
7516 enum GeneratedField {
7517 GroupDeltas,
7518 }
7519 impl<'de> serde::Deserialize<'de> for GeneratedField {
7520 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7521 where
7522 D: serde::Deserializer<'de>,
7523 {
7524 struct GeneratedVisitor;
7525
7526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7527 type Value = GeneratedField;
7528
7529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7530 write!(formatter, "expected one of: {:?}", &FIELDS)
7531 }
7532
7533 #[allow(unused_variables)]
7534 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7535 where
7536 E: serde::de::Error,
7537 {
7538 match value {
7539 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
7540 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7541 }
7542 }
7543 }
7544 deserializer.deserialize_identifier(GeneratedVisitor)
7545 }
7546 }
7547 struct GeneratedVisitor;
7548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7549 type Value = hummock_version_delta::GroupDeltas;
7550
7551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7552 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
7553 }
7554
7555 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
7556 where
7557 V: serde::de::MapAccess<'de>,
7558 {
7559 let mut group_deltas__ = None;
7560 while let Some(k) = map_.next_key()? {
7561 match k {
7562 GeneratedField::GroupDeltas => {
7563 if group_deltas__.is_some() {
7564 return Err(serde::de::Error::duplicate_field("groupDeltas"));
7565 }
7566 group_deltas__ = Some(map_.next_value()?);
7567 }
7568 }
7569 }
7570 Ok(hummock_version_delta::GroupDeltas {
7571 group_deltas: group_deltas__.unwrap_or_default(),
7572 })
7573 }
7574 }
7575 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
7576 }
7577}
7578impl serde::Serialize for HummockVersionDeltas {
7579 #[allow(deprecated)]
7580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7581 where
7582 S: serde::Serializer,
7583 {
7584 use serde::ser::SerializeStruct;
7585 let mut len = 0;
7586 if !self.version_deltas.is_empty() {
7587 len += 1;
7588 }
7589 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
7590 if !self.version_deltas.is_empty() {
7591 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
7592 }
7593 struct_ser.end()
7594 }
7595}
7596impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
7597 #[allow(deprecated)]
7598 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7599 where
7600 D: serde::Deserializer<'de>,
7601 {
7602 const FIELDS: &[&str] = &[
7603 "version_deltas",
7604 "versionDeltas",
7605 ];
7606
7607 #[allow(clippy::enum_variant_names)]
7608 enum GeneratedField {
7609 VersionDeltas,
7610 }
7611 impl<'de> serde::Deserialize<'de> for GeneratedField {
7612 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7613 where
7614 D: serde::Deserializer<'de>,
7615 {
7616 struct GeneratedVisitor;
7617
7618 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7619 type Value = GeneratedField;
7620
7621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7622 write!(formatter, "expected one of: {:?}", &FIELDS)
7623 }
7624
7625 #[allow(unused_variables)]
7626 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7627 where
7628 E: serde::de::Error,
7629 {
7630 match value {
7631 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
7632 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7633 }
7634 }
7635 }
7636 deserializer.deserialize_identifier(GeneratedVisitor)
7637 }
7638 }
7639 struct GeneratedVisitor;
7640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7641 type Value = HummockVersionDeltas;
7642
7643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7644 formatter.write_str("struct hummock.HummockVersionDeltas")
7645 }
7646
7647 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
7648 where
7649 V: serde::de::MapAccess<'de>,
7650 {
7651 let mut version_deltas__ = None;
7652 while let Some(k) = map_.next_key()? {
7653 match k {
7654 GeneratedField::VersionDeltas => {
7655 if version_deltas__.is_some() {
7656 return Err(serde::de::Error::duplicate_field("versionDeltas"));
7657 }
7658 version_deltas__ = Some(map_.next_value()?);
7659 }
7660 }
7661 }
7662 Ok(HummockVersionDeltas {
7663 version_deltas: version_deltas__.unwrap_or_default(),
7664 })
7665 }
7666 }
7667 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
7668 }
7669}
7670impl serde::Serialize for HummockVersionStats {
7671 #[allow(deprecated)]
7672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7673 where
7674 S: serde::Serializer,
7675 {
7676 use serde::ser::SerializeStruct;
7677 let mut len = 0;
7678 if self.hummock_version_id != 0 {
7679 len += 1;
7680 }
7681 if !self.table_stats.is_empty() {
7682 len += 1;
7683 }
7684 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
7685 if self.hummock_version_id != 0 {
7686 #[allow(clippy::needless_borrow)]
7687 #[allow(clippy::needless_borrows_for_generic_args)]
7688 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
7689 }
7690 if !self.table_stats.is_empty() {
7691 struct_ser.serialize_field("tableStats", &self.table_stats)?;
7692 }
7693 struct_ser.end()
7694 }
7695}
7696impl<'de> serde::Deserialize<'de> for HummockVersionStats {
7697 #[allow(deprecated)]
7698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7699 where
7700 D: serde::Deserializer<'de>,
7701 {
7702 const FIELDS: &[&str] = &[
7703 "hummock_version_id",
7704 "hummockVersionId",
7705 "table_stats",
7706 "tableStats",
7707 ];
7708
7709 #[allow(clippy::enum_variant_names)]
7710 enum GeneratedField {
7711 HummockVersionId,
7712 TableStats,
7713 }
7714 impl<'de> serde::Deserialize<'de> for GeneratedField {
7715 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7716 where
7717 D: serde::Deserializer<'de>,
7718 {
7719 struct GeneratedVisitor;
7720
7721 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7722 type Value = GeneratedField;
7723
7724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7725 write!(formatter, "expected one of: {:?}", &FIELDS)
7726 }
7727
7728 #[allow(unused_variables)]
7729 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7730 where
7731 E: serde::de::Error,
7732 {
7733 match value {
7734 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
7735 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
7736 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7737 }
7738 }
7739 }
7740 deserializer.deserialize_identifier(GeneratedVisitor)
7741 }
7742 }
7743 struct GeneratedVisitor;
7744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7745 type Value = HummockVersionStats;
7746
7747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7748 formatter.write_str("struct hummock.HummockVersionStats")
7749 }
7750
7751 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
7752 where
7753 V: serde::de::MapAccess<'de>,
7754 {
7755 let mut hummock_version_id__ = None;
7756 let mut table_stats__ = None;
7757 while let Some(k) = map_.next_key()? {
7758 match k {
7759 GeneratedField::HummockVersionId => {
7760 if hummock_version_id__.is_some() {
7761 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
7762 }
7763 hummock_version_id__ =
7764 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7765 ;
7766 }
7767 GeneratedField::TableStats => {
7768 if table_stats__.is_some() {
7769 return Err(serde::de::Error::duplicate_field("tableStats"));
7770 }
7771 table_stats__ = Some(
7772 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7773 .into_iter().map(|(k,v)| (k.0, v)).collect()
7774 );
7775 }
7776 }
7777 }
7778 Ok(HummockVersionStats {
7779 hummock_version_id: hummock_version_id__.unwrap_or_default(),
7780 table_stats: table_stats__.unwrap_or_default(),
7781 })
7782 }
7783 }
7784 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
7785 }
7786}
7787impl serde::Serialize for InitMetadataForReplayRequest {
7788 #[allow(deprecated)]
7789 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7790 where
7791 S: serde::Serializer,
7792 {
7793 use serde::ser::SerializeStruct;
7794 let mut len = 0;
7795 if !self.tables.is_empty() {
7796 len += 1;
7797 }
7798 if !self.compaction_groups.is_empty() {
7799 len += 1;
7800 }
7801 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
7802 if !self.tables.is_empty() {
7803 struct_ser.serialize_field("tables", &self.tables)?;
7804 }
7805 if !self.compaction_groups.is_empty() {
7806 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
7807 }
7808 struct_ser.end()
7809 }
7810}
7811impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
7812 #[allow(deprecated)]
7813 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7814 where
7815 D: serde::Deserializer<'de>,
7816 {
7817 const FIELDS: &[&str] = &[
7818 "tables",
7819 "compaction_groups",
7820 "compactionGroups",
7821 ];
7822
7823 #[allow(clippy::enum_variant_names)]
7824 enum GeneratedField {
7825 Tables,
7826 CompactionGroups,
7827 }
7828 impl<'de> serde::Deserialize<'de> for GeneratedField {
7829 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7830 where
7831 D: serde::Deserializer<'de>,
7832 {
7833 struct GeneratedVisitor;
7834
7835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7836 type Value = GeneratedField;
7837
7838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7839 write!(formatter, "expected one of: {:?}", &FIELDS)
7840 }
7841
7842 #[allow(unused_variables)]
7843 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7844 where
7845 E: serde::de::Error,
7846 {
7847 match value {
7848 "tables" => Ok(GeneratedField::Tables),
7849 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
7850 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7851 }
7852 }
7853 }
7854 deserializer.deserialize_identifier(GeneratedVisitor)
7855 }
7856 }
7857 struct GeneratedVisitor;
7858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7859 type Value = InitMetadataForReplayRequest;
7860
7861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7862 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
7863 }
7864
7865 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
7866 where
7867 V: serde::de::MapAccess<'de>,
7868 {
7869 let mut tables__ = None;
7870 let mut compaction_groups__ = None;
7871 while let Some(k) = map_.next_key()? {
7872 match k {
7873 GeneratedField::Tables => {
7874 if tables__.is_some() {
7875 return Err(serde::de::Error::duplicate_field("tables"));
7876 }
7877 tables__ = Some(map_.next_value()?);
7878 }
7879 GeneratedField::CompactionGroups => {
7880 if compaction_groups__.is_some() {
7881 return Err(serde::de::Error::duplicate_field("compactionGroups"));
7882 }
7883 compaction_groups__ = Some(map_.next_value()?);
7884 }
7885 }
7886 }
7887 Ok(InitMetadataForReplayRequest {
7888 tables: tables__.unwrap_or_default(),
7889 compaction_groups: compaction_groups__.unwrap_or_default(),
7890 })
7891 }
7892 }
7893 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
7894 }
7895}
7896impl serde::Serialize for InitMetadataForReplayResponse {
7897 #[allow(deprecated)]
7898 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7899 where
7900 S: serde::Serializer,
7901 {
7902 use serde::ser::SerializeStruct;
7903 let len = 0;
7904 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
7905 struct_ser.end()
7906 }
7907}
7908impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
7909 #[allow(deprecated)]
7910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7911 where
7912 D: serde::Deserializer<'de>,
7913 {
7914 const FIELDS: &[&str] = &[
7915 ];
7916
7917 #[allow(clippy::enum_variant_names)]
7918 enum GeneratedField {
7919 }
7920 impl<'de> serde::Deserialize<'de> for GeneratedField {
7921 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7922 where
7923 D: serde::Deserializer<'de>,
7924 {
7925 struct GeneratedVisitor;
7926
7927 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7928 type Value = GeneratedField;
7929
7930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7931 write!(formatter, "expected one of: {:?}", &FIELDS)
7932 }
7933
7934 #[allow(unused_variables)]
7935 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7936 where
7937 E: serde::de::Error,
7938 {
7939 Err(serde::de::Error::unknown_field(value, FIELDS))
7940 }
7941 }
7942 deserializer.deserialize_identifier(GeneratedVisitor)
7943 }
7944 }
7945 struct GeneratedVisitor;
7946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7947 type Value = InitMetadataForReplayResponse;
7948
7949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7950 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
7951 }
7952
7953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
7954 where
7955 V: serde::de::MapAccess<'de>,
7956 {
7957 while map_.next_key::<GeneratedField>()?.is_some() {
7958 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7959 }
7960 Ok(InitMetadataForReplayResponse {
7961 })
7962 }
7963 }
7964 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
7965 }
7966}
7967impl serde::Serialize for InputLevel {
7968 #[allow(deprecated)]
7969 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7970 where
7971 S: serde::Serializer,
7972 {
7973 use serde::ser::SerializeStruct;
7974 let mut len = 0;
7975 if self.level_idx != 0 {
7976 len += 1;
7977 }
7978 if self.level_type != 0 {
7979 len += 1;
7980 }
7981 if !self.table_infos.is_empty() {
7982 len += 1;
7983 }
7984 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
7985 if self.level_idx != 0 {
7986 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7987 }
7988 if self.level_type != 0 {
7989 let v = LevelType::try_from(self.level_type)
7990 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7991 struct_ser.serialize_field("levelType", &v)?;
7992 }
7993 if !self.table_infos.is_empty() {
7994 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7995 }
7996 struct_ser.end()
7997 }
7998}
7999impl<'de> serde::Deserialize<'de> for InputLevel {
8000 #[allow(deprecated)]
8001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8002 where
8003 D: serde::Deserializer<'de>,
8004 {
8005 const FIELDS: &[&str] = &[
8006 "level_idx",
8007 "levelIdx",
8008 "level_type",
8009 "levelType",
8010 "table_infos",
8011 "tableInfos",
8012 ];
8013
8014 #[allow(clippy::enum_variant_names)]
8015 enum GeneratedField {
8016 LevelIdx,
8017 LevelType,
8018 TableInfos,
8019 }
8020 impl<'de> serde::Deserialize<'de> for GeneratedField {
8021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8022 where
8023 D: serde::Deserializer<'de>,
8024 {
8025 struct GeneratedVisitor;
8026
8027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8028 type Value = GeneratedField;
8029
8030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8031 write!(formatter, "expected one of: {:?}", &FIELDS)
8032 }
8033
8034 #[allow(unused_variables)]
8035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8036 where
8037 E: serde::de::Error,
8038 {
8039 match value {
8040 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8041 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8042 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8043 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8044 }
8045 }
8046 }
8047 deserializer.deserialize_identifier(GeneratedVisitor)
8048 }
8049 }
8050 struct GeneratedVisitor;
8051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8052 type Value = InputLevel;
8053
8054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8055 formatter.write_str("struct hummock.InputLevel")
8056 }
8057
8058 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
8059 where
8060 V: serde::de::MapAccess<'de>,
8061 {
8062 let mut level_idx__ = None;
8063 let mut level_type__ = None;
8064 let mut table_infos__ = None;
8065 while let Some(k) = map_.next_key()? {
8066 match k {
8067 GeneratedField::LevelIdx => {
8068 if level_idx__.is_some() {
8069 return Err(serde::de::Error::duplicate_field("levelIdx"));
8070 }
8071 level_idx__ =
8072 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8073 ;
8074 }
8075 GeneratedField::LevelType => {
8076 if level_type__.is_some() {
8077 return Err(serde::de::Error::duplicate_field("levelType"));
8078 }
8079 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8080 }
8081 GeneratedField::TableInfos => {
8082 if table_infos__.is_some() {
8083 return Err(serde::de::Error::duplicate_field("tableInfos"));
8084 }
8085 table_infos__ = Some(map_.next_value()?);
8086 }
8087 }
8088 }
8089 Ok(InputLevel {
8090 level_idx: level_idx__.unwrap_or_default(),
8091 level_type: level_type__.unwrap_or_default(),
8092 table_infos: table_infos__.unwrap_or_default(),
8093 })
8094 }
8095 }
8096 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
8097 }
8098}
8099impl serde::Serialize for IntraLevelDelta {
8100 #[allow(deprecated)]
8101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8102 where
8103 S: serde::Serializer,
8104 {
8105 use serde::ser::SerializeStruct;
8106 let mut len = 0;
8107 if self.level_idx != 0 {
8108 len += 1;
8109 }
8110 if self.l0_sub_level_id != 0 {
8111 len += 1;
8112 }
8113 if !self.removed_table_ids.is_empty() {
8114 len += 1;
8115 }
8116 if !self.inserted_table_infos.is_empty() {
8117 len += 1;
8118 }
8119 if self.vnode_partition_count != 0 {
8120 len += 1;
8121 }
8122 if self.compaction_group_version_id != 0 {
8123 len += 1;
8124 }
8125 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
8126 if self.level_idx != 0 {
8127 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8128 }
8129 if self.l0_sub_level_id != 0 {
8130 #[allow(clippy::needless_borrow)]
8131 #[allow(clippy::needless_borrows_for_generic_args)]
8132 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
8133 }
8134 if !self.removed_table_ids.is_empty() {
8135 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8136 }
8137 if !self.inserted_table_infos.is_empty() {
8138 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
8139 }
8140 if self.vnode_partition_count != 0 {
8141 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8142 }
8143 if self.compaction_group_version_id != 0 {
8144 #[allow(clippy::needless_borrow)]
8145 #[allow(clippy::needless_borrows_for_generic_args)]
8146 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
8147 }
8148 struct_ser.end()
8149 }
8150}
8151impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
8152 #[allow(deprecated)]
8153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8154 where
8155 D: serde::Deserializer<'de>,
8156 {
8157 const FIELDS: &[&str] = &[
8158 "level_idx",
8159 "levelIdx",
8160 "l0_sub_level_id",
8161 "l0SubLevelId",
8162 "removed_table_ids",
8163 "removedTableIds",
8164 "inserted_table_infos",
8165 "insertedTableInfos",
8166 "vnode_partition_count",
8167 "vnodePartitionCount",
8168 "compaction_group_version_id",
8169 "compactionGroupVersionId",
8170 ];
8171
8172 #[allow(clippy::enum_variant_names)]
8173 enum GeneratedField {
8174 LevelIdx,
8175 L0SubLevelId,
8176 RemovedTableIds,
8177 InsertedTableInfos,
8178 VnodePartitionCount,
8179 CompactionGroupVersionId,
8180 }
8181 impl<'de> serde::Deserialize<'de> for GeneratedField {
8182 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8183 where
8184 D: serde::Deserializer<'de>,
8185 {
8186 struct GeneratedVisitor;
8187
8188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8189 type Value = GeneratedField;
8190
8191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8192 write!(formatter, "expected one of: {:?}", &FIELDS)
8193 }
8194
8195 #[allow(unused_variables)]
8196 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8197 where
8198 E: serde::de::Error,
8199 {
8200 match value {
8201 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8202 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
8203 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
8204 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
8205 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8206 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
8207 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8208 }
8209 }
8210 }
8211 deserializer.deserialize_identifier(GeneratedVisitor)
8212 }
8213 }
8214 struct GeneratedVisitor;
8215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8216 type Value = IntraLevelDelta;
8217
8218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8219 formatter.write_str("struct hummock.IntraLevelDelta")
8220 }
8221
8222 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
8223 where
8224 V: serde::de::MapAccess<'de>,
8225 {
8226 let mut level_idx__ = None;
8227 let mut l0_sub_level_id__ = None;
8228 let mut removed_table_ids__ = None;
8229 let mut inserted_table_infos__ = None;
8230 let mut vnode_partition_count__ = None;
8231 let mut compaction_group_version_id__ = None;
8232 while let Some(k) = map_.next_key()? {
8233 match k {
8234 GeneratedField::LevelIdx => {
8235 if level_idx__.is_some() {
8236 return Err(serde::de::Error::duplicate_field("levelIdx"));
8237 }
8238 level_idx__ =
8239 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8240 ;
8241 }
8242 GeneratedField::L0SubLevelId => {
8243 if l0_sub_level_id__.is_some() {
8244 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
8245 }
8246 l0_sub_level_id__ =
8247 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8248 ;
8249 }
8250 GeneratedField::RemovedTableIds => {
8251 if removed_table_ids__.is_some() {
8252 return Err(serde::de::Error::duplicate_field("removedTableIds"));
8253 }
8254 removed_table_ids__ =
8255 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8256 .into_iter().map(|x| x.0).collect())
8257 ;
8258 }
8259 GeneratedField::InsertedTableInfos => {
8260 if inserted_table_infos__.is_some() {
8261 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
8262 }
8263 inserted_table_infos__ = Some(map_.next_value()?);
8264 }
8265 GeneratedField::VnodePartitionCount => {
8266 if vnode_partition_count__.is_some() {
8267 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
8268 }
8269 vnode_partition_count__ =
8270 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8271 ;
8272 }
8273 GeneratedField::CompactionGroupVersionId => {
8274 if compaction_group_version_id__.is_some() {
8275 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
8276 }
8277 compaction_group_version_id__ =
8278 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8279 ;
8280 }
8281 }
8282 }
8283 Ok(IntraLevelDelta {
8284 level_idx: level_idx__.unwrap_or_default(),
8285 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
8286 removed_table_ids: removed_table_ids__.unwrap_or_default(),
8287 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
8288 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
8289 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
8290 })
8291 }
8292 }
8293 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
8294 }
8295}
8296impl serde::Serialize for KeyRange {
8297 #[allow(deprecated)]
8298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8299 where
8300 S: serde::Serializer,
8301 {
8302 use serde::ser::SerializeStruct;
8303 let mut len = 0;
8304 if !self.left.is_empty() {
8305 len += 1;
8306 }
8307 if !self.right.is_empty() {
8308 len += 1;
8309 }
8310 if self.right_exclusive {
8311 len += 1;
8312 }
8313 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
8314 if !self.left.is_empty() {
8315 #[allow(clippy::needless_borrow)]
8316 #[allow(clippy::needless_borrows_for_generic_args)]
8317 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
8318 }
8319 if !self.right.is_empty() {
8320 #[allow(clippy::needless_borrow)]
8321 #[allow(clippy::needless_borrows_for_generic_args)]
8322 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
8323 }
8324 if self.right_exclusive {
8325 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
8326 }
8327 struct_ser.end()
8328 }
8329}
8330impl<'de> serde::Deserialize<'de> for KeyRange {
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 "left",
8338 "right",
8339 "right_exclusive",
8340 "rightExclusive",
8341 ];
8342
8343 #[allow(clippy::enum_variant_names)]
8344 enum GeneratedField {
8345 Left,
8346 Right,
8347 RightExclusive,
8348 }
8349 impl<'de> serde::Deserialize<'de> for GeneratedField {
8350 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8351 where
8352 D: serde::Deserializer<'de>,
8353 {
8354 struct GeneratedVisitor;
8355
8356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8357 type Value = GeneratedField;
8358
8359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8360 write!(formatter, "expected one of: {:?}", &FIELDS)
8361 }
8362
8363 #[allow(unused_variables)]
8364 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8365 where
8366 E: serde::de::Error,
8367 {
8368 match value {
8369 "left" => Ok(GeneratedField::Left),
8370 "right" => Ok(GeneratedField::Right),
8371 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
8372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8373 }
8374 }
8375 }
8376 deserializer.deserialize_identifier(GeneratedVisitor)
8377 }
8378 }
8379 struct GeneratedVisitor;
8380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8381 type Value = KeyRange;
8382
8383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8384 formatter.write_str("struct hummock.KeyRange")
8385 }
8386
8387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
8388 where
8389 V: serde::de::MapAccess<'de>,
8390 {
8391 let mut left__ = None;
8392 let mut right__ = None;
8393 let mut right_exclusive__ = None;
8394 while let Some(k) = map_.next_key()? {
8395 match k {
8396 GeneratedField::Left => {
8397 if left__.is_some() {
8398 return Err(serde::de::Error::duplicate_field("left"));
8399 }
8400 left__ =
8401 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
8402 ;
8403 }
8404 GeneratedField::Right => {
8405 if right__.is_some() {
8406 return Err(serde::de::Error::duplicate_field("right"));
8407 }
8408 right__ =
8409 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
8410 ;
8411 }
8412 GeneratedField::RightExclusive => {
8413 if right_exclusive__.is_some() {
8414 return Err(serde::de::Error::duplicate_field("rightExclusive"));
8415 }
8416 right_exclusive__ = Some(map_.next_value()?);
8417 }
8418 }
8419 }
8420 Ok(KeyRange {
8421 left: left__.unwrap_or_default(),
8422 right: right__.unwrap_or_default(),
8423 right_exclusive: right_exclusive__.unwrap_or_default(),
8424 })
8425 }
8426 }
8427 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
8428 }
8429}
8430impl serde::Serialize for Level {
8431 #[allow(deprecated)]
8432 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8433 where
8434 S: serde::Serializer,
8435 {
8436 use serde::ser::SerializeStruct;
8437 let mut len = 0;
8438 if self.level_idx != 0 {
8439 len += 1;
8440 }
8441 if self.level_type != 0 {
8442 len += 1;
8443 }
8444 if !self.table_infos.is_empty() {
8445 len += 1;
8446 }
8447 if self.total_file_size != 0 {
8448 len += 1;
8449 }
8450 if self.sub_level_id != 0 {
8451 len += 1;
8452 }
8453 if self.uncompressed_file_size != 0 {
8454 len += 1;
8455 }
8456 if self.vnode_partition_count != 0 {
8457 len += 1;
8458 }
8459 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
8460 if self.level_idx != 0 {
8461 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8462 }
8463 if self.level_type != 0 {
8464 let v = LevelType::try_from(self.level_type)
8465 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
8466 struct_ser.serialize_field("levelType", &v)?;
8467 }
8468 if !self.table_infos.is_empty() {
8469 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
8470 }
8471 if self.total_file_size != 0 {
8472 #[allow(clippy::needless_borrow)]
8473 #[allow(clippy::needless_borrows_for_generic_args)]
8474 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8475 }
8476 if self.sub_level_id != 0 {
8477 #[allow(clippy::needless_borrow)]
8478 #[allow(clippy::needless_borrows_for_generic_args)]
8479 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
8480 }
8481 if self.uncompressed_file_size != 0 {
8482 #[allow(clippy::needless_borrow)]
8483 #[allow(clippy::needless_borrows_for_generic_args)]
8484 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
8485 }
8486 if self.vnode_partition_count != 0 {
8487 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8488 }
8489 struct_ser.end()
8490 }
8491}
8492impl<'de> serde::Deserialize<'de> for Level {
8493 #[allow(deprecated)]
8494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8495 where
8496 D: serde::Deserializer<'de>,
8497 {
8498 const FIELDS: &[&str] = &[
8499 "level_idx",
8500 "levelIdx",
8501 "level_type",
8502 "levelType",
8503 "table_infos",
8504 "tableInfos",
8505 "total_file_size",
8506 "totalFileSize",
8507 "sub_level_id",
8508 "subLevelId",
8509 "uncompressed_file_size",
8510 "uncompressedFileSize",
8511 "vnode_partition_count",
8512 "vnodePartitionCount",
8513 ];
8514
8515 #[allow(clippy::enum_variant_names)]
8516 enum GeneratedField {
8517 LevelIdx,
8518 LevelType,
8519 TableInfos,
8520 TotalFileSize,
8521 SubLevelId,
8522 UncompressedFileSize,
8523 VnodePartitionCount,
8524 }
8525 impl<'de> serde::Deserialize<'de> for GeneratedField {
8526 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8527 where
8528 D: serde::Deserializer<'de>,
8529 {
8530 struct GeneratedVisitor;
8531
8532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8533 type Value = GeneratedField;
8534
8535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8536 write!(formatter, "expected one of: {:?}", &FIELDS)
8537 }
8538
8539 #[allow(unused_variables)]
8540 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8541 where
8542 E: serde::de::Error,
8543 {
8544 match value {
8545 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8546 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8547 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8548 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8549 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
8550 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
8551 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8552 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8553 }
8554 }
8555 }
8556 deserializer.deserialize_identifier(GeneratedVisitor)
8557 }
8558 }
8559 struct GeneratedVisitor;
8560 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8561 type Value = Level;
8562
8563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8564 formatter.write_str("struct hummock.Level")
8565 }
8566
8567 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
8568 where
8569 V: serde::de::MapAccess<'de>,
8570 {
8571 let mut level_idx__ = None;
8572 let mut level_type__ = None;
8573 let mut table_infos__ = None;
8574 let mut total_file_size__ = None;
8575 let mut sub_level_id__ = None;
8576 let mut uncompressed_file_size__ = None;
8577 let mut vnode_partition_count__ = None;
8578 while let Some(k) = map_.next_key()? {
8579 match k {
8580 GeneratedField::LevelIdx => {
8581 if level_idx__.is_some() {
8582 return Err(serde::de::Error::duplicate_field("levelIdx"));
8583 }
8584 level_idx__ =
8585 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8586 ;
8587 }
8588 GeneratedField::LevelType => {
8589 if level_type__.is_some() {
8590 return Err(serde::de::Error::duplicate_field("levelType"));
8591 }
8592 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8593 }
8594 GeneratedField::TableInfos => {
8595 if table_infos__.is_some() {
8596 return Err(serde::de::Error::duplicate_field("tableInfos"));
8597 }
8598 table_infos__ = Some(map_.next_value()?);
8599 }
8600 GeneratedField::TotalFileSize => {
8601 if total_file_size__.is_some() {
8602 return Err(serde::de::Error::duplicate_field("totalFileSize"));
8603 }
8604 total_file_size__ =
8605 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8606 ;
8607 }
8608 GeneratedField::SubLevelId => {
8609 if sub_level_id__.is_some() {
8610 return Err(serde::de::Error::duplicate_field("subLevelId"));
8611 }
8612 sub_level_id__ =
8613 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8614 ;
8615 }
8616 GeneratedField::UncompressedFileSize => {
8617 if uncompressed_file_size__.is_some() {
8618 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
8619 }
8620 uncompressed_file_size__ =
8621 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8622 ;
8623 }
8624 GeneratedField::VnodePartitionCount => {
8625 if vnode_partition_count__.is_some() {
8626 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
8627 }
8628 vnode_partition_count__ =
8629 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8630 ;
8631 }
8632 }
8633 }
8634 Ok(Level {
8635 level_idx: level_idx__.unwrap_or_default(),
8636 level_type: level_type__.unwrap_or_default(),
8637 table_infos: table_infos__.unwrap_or_default(),
8638 total_file_size: total_file_size__.unwrap_or_default(),
8639 sub_level_id: sub_level_id__.unwrap_or_default(),
8640 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
8641 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
8642 })
8643 }
8644 }
8645 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
8646 }
8647}
8648impl serde::Serialize for LevelHandler {
8649 #[allow(deprecated)]
8650 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8651 where
8652 S: serde::Serializer,
8653 {
8654 use serde::ser::SerializeStruct;
8655 let mut len = 0;
8656 if self.level != 0 {
8657 len += 1;
8658 }
8659 if !self.tasks.is_empty() {
8660 len += 1;
8661 }
8662 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
8663 if self.level != 0 {
8664 struct_ser.serialize_field("level", &self.level)?;
8665 }
8666 if !self.tasks.is_empty() {
8667 struct_ser.serialize_field("tasks", &self.tasks)?;
8668 }
8669 struct_ser.end()
8670 }
8671}
8672impl<'de> serde::Deserialize<'de> for LevelHandler {
8673 #[allow(deprecated)]
8674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8675 where
8676 D: serde::Deserializer<'de>,
8677 {
8678 const FIELDS: &[&str] = &[
8679 "level",
8680 "tasks",
8681 ];
8682
8683 #[allow(clippy::enum_variant_names)]
8684 enum GeneratedField {
8685 Level,
8686 Tasks,
8687 }
8688 impl<'de> serde::Deserialize<'de> for GeneratedField {
8689 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8690 where
8691 D: serde::Deserializer<'de>,
8692 {
8693 struct GeneratedVisitor;
8694
8695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8696 type Value = GeneratedField;
8697
8698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8699 write!(formatter, "expected one of: {:?}", &FIELDS)
8700 }
8701
8702 #[allow(unused_variables)]
8703 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8704 where
8705 E: serde::de::Error,
8706 {
8707 match value {
8708 "level" => Ok(GeneratedField::Level),
8709 "tasks" => Ok(GeneratedField::Tasks),
8710 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8711 }
8712 }
8713 }
8714 deserializer.deserialize_identifier(GeneratedVisitor)
8715 }
8716 }
8717 struct GeneratedVisitor;
8718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8719 type Value = LevelHandler;
8720
8721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8722 formatter.write_str("struct hummock.LevelHandler")
8723 }
8724
8725 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
8726 where
8727 V: serde::de::MapAccess<'de>,
8728 {
8729 let mut level__ = None;
8730 let mut tasks__ = None;
8731 while let Some(k) = map_.next_key()? {
8732 match k {
8733 GeneratedField::Level => {
8734 if level__.is_some() {
8735 return Err(serde::de::Error::duplicate_field("level"));
8736 }
8737 level__ =
8738 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8739 ;
8740 }
8741 GeneratedField::Tasks => {
8742 if tasks__.is_some() {
8743 return Err(serde::de::Error::duplicate_field("tasks"));
8744 }
8745 tasks__ = Some(map_.next_value()?);
8746 }
8747 }
8748 }
8749 Ok(LevelHandler {
8750 level: level__.unwrap_or_default(),
8751 tasks: tasks__.unwrap_or_default(),
8752 })
8753 }
8754 }
8755 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
8756 }
8757}
8758impl serde::Serialize for level_handler::RunningCompactTask {
8759 #[allow(deprecated)]
8760 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8761 where
8762 S: serde::Serializer,
8763 {
8764 use serde::ser::SerializeStruct;
8765 let mut len = 0;
8766 if self.task_id != 0 {
8767 len += 1;
8768 }
8769 if !self.ssts.is_empty() {
8770 len += 1;
8771 }
8772 if self.total_file_size != 0 {
8773 len += 1;
8774 }
8775 if self.target_level != 0 {
8776 len += 1;
8777 }
8778 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
8779 if self.task_id != 0 {
8780 #[allow(clippy::needless_borrow)]
8781 #[allow(clippy::needless_borrows_for_generic_args)]
8782 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
8783 }
8784 if !self.ssts.is_empty() {
8785 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8786 }
8787 if self.total_file_size != 0 {
8788 #[allow(clippy::needless_borrow)]
8789 #[allow(clippy::needless_borrows_for_generic_args)]
8790 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8791 }
8792 if self.target_level != 0 {
8793 struct_ser.serialize_field("targetLevel", &self.target_level)?;
8794 }
8795 struct_ser.end()
8796 }
8797}
8798impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
8799 #[allow(deprecated)]
8800 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8801 where
8802 D: serde::Deserializer<'de>,
8803 {
8804 const FIELDS: &[&str] = &[
8805 "task_id",
8806 "taskId",
8807 "ssts",
8808 "total_file_size",
8809 "totalFileSize",
8810 "target_level",
8811 "targetLevel",
8812 ];
8813
8814 #[allow(clippy::enum_variant_names)]
8815 enum GeneratedField {
8816 TaskId,
8817 Ssts,
8818 TotalFileSize,
8819 TargetLevel,
8820 }
8821 impl<'de> serde::Deserialize<'de> for GeneratedField {
8822 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8823 where
8824 D: serde::Deserializer<'de>,
8825 {
8826 struct GeneratedVisitor;
8827
8828 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8829 type Value = GeneratedField;
8830
8831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8832 write!(formatter, "expected one of: {:?}", &FIELDS)
8833 }
8834
8835 #[allow(unused_variables)]
8836 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8837 where
8838 E: serde::de::Error,
8839 {
8840 match value {
8841 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8842 "ssts" => Ok(GeneratedField::Ssts),
8843 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8844 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
8845 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8846 }
8847 }
8848 }
8849 deserializer.deserialize_identifier(GeneratedVisitor)
8850 }
8851 }
8852 struct GeneratedVisitor;
8853 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8854 type Value = level_handler::RunningCompactTask;
8855
8856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8857 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
8858 }
8859
8860 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
8861 where
8862 V: serde::de::MapAccess<'de>,
8863 {
8864 let mut task_id__ = None;
8865 let mut ssts__ = None;
8866 let mut total_file_size__ = None;
8867 let mut target_level__ = None;
8868 while let Some(k) = map_.next_key()? {
8869 match k {
8870 GeneratedField::TaskId => {
8871 if task_id__.is_some() {
8872 return Err(serde::de::Error::duplicate_field("taskId"));
8873 }
8874 task_id__ =
8875 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8876 ;
8877 }
8878 GeneratedField::Ssts => {
8879 if ssts__.is_some() {
8880 return Err(serde::de::Error::duplicate_field("ssts"));
8881 }
8882 ssts__ =
8883 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8884 .into_iter().map(|x| x.0).collect())
8885 ;
8886 }
8887 GeneratedField::TotalFileSize => {
8888 if total_file_size__.is_some() {
8889 return Err(serde::de::Error::duplicate_field("totalFileSize"));
8890 }
8891 total_file_size__ =
8892 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8893 ;
8894 }
8895 GeneratedField::TargetLevel => {
8896 if target_level__.is_some() {
8897 return Err(serde::de::Error::duplicate_field("targetLevel"));
8898 }
8899 target_level__ =
8900 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8901 ;
8902 }
8903 }
8904 }
8905 Ok(level_handler::RunningCompactTask {
8906 task_id: task_id__.unwrap_or_default(),
8907 ssts: ssts__.unwrap_or_default(),
8908 total_file_size: total_file_size__.unwrap_or_default(),
8909 target_level: target_level__.unwrap_or_default(),
8910 })
8911 }
8912 }
8913 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
8914 }
8915}
8916impl serde::Serialize for LevelType {
8917 #[allow(deprecated)]
8918 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8919 where
8920 S: serde::Serializer,
8921 {
8922 let variant = match self {
8923 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
8924 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
8925 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
8926 };
8927 serializer.serialize_str(variant)
8928 }
8929}
8930impl<'de> serde::Deserialize<'de> for LevelType {
8931 #[allow(deprecated)]
8932 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8933 where
8934 D: serde::Deserializer<'de>,
8935 {
8936 const FIELDS: &[&str] = &[
8937 "LEVEL_TYPE_UNSPECIFIED",
8938 "LEVEL_TYPE_NONOVERLAPPING",
8939 "LEVEL_TYPE_OVERLAPPING",
8940 ];
8941
8942 struct GeneratedVisitor;
8943
8944 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8945 type Value = LevelType;
8946
8947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8948 write!(formatter, "expected one of: {:?}", &FIELDS)
8949 }
8950
8951 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8952 where
8953 E: serde::de::Error,
8954 {
8955 i32::try_from(v)
8956 .ok()
8957 .and_then(|x| x.try_into().ok())
8958 .ok_or_else(|| {
8959 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8960 })
8961 }
8962
8963 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8964 where
8965 E: serde::de::Error,
8966 {
8967 i32::try_from(v)
8968 .ok()
8969 .and_then(|x| x.try_into().ok())
8970 .ok_or_else(|| {
8971 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8972 })
8973 }
8974
8975 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8976 where
8977 E: serde::de::Error,
8978 {
8979 match value {
8980 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
8981 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
8982 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
8983 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8984 }
8985 }
8986 }
8987 deserializer.deserialize_any(GeneratedVisitor)
8988 }
8989}
8990impl serde::Serialize for ListActiveWriteLimitRequest {
8991 #[allow(deprecated)]
8992 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8993 where
8994 S: serde::Serializer,
8995 {
8996 use serde::ser::SerializeStruct;
8997 let len = 0;
8998 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
8999 struct_ser.end()
9000 }
9001}
9002impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
9003 #[allow(deprecated)]
9004 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9005 where
9006 D: serde::Deserializer<'de>,
9007 {
9008 const FIELDS: &[&str] = &[
9009 ];
9010
9011 #[allow(clippy::enum_variant_names)]
9012 enum GeneratedField {
9013 }
9014 impl<'de> serde::Deserialize<'de> for GeneratedField {
9015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9016 where
9017 D: serde::Deserializer<'de>,
9018 {
9019 struct GeneratedVisitor;
9020
9021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9022 type Value = GeneratedField;
9023
9024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9025 write!(formatter, "expected one of: {:?}", &FIELDS)
9026 }
9027
9028 #[allow(unused_variables)]
9029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9030 where
9031 E: serde::de::Error,
9032 {
9033 Err(serde::de::Error::unknown_field(value, FIELDS))
9034 }
9035 }
9036 deserializer.deserialize_identifier(GeneratedVisitor)
9037 }
9038 }
9039 struct GeneratedVisitor;
9040 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9041 type Value = ListActiveWriteLimitRequest;
9042
9043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9044 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
9045 }
9046
9047 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
9048 where
9049 V: serde::de::MapAccess<'de>,
9050 {
9051 while map_.next_key::<GeneratedField>()?.is_some() {
9052 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9053 }
9054 Ok(ListActiveWriteLimitRequest {
9055 })
9056 }
9057 }
9058 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
9059 }
9060}
9061impl serde::Serialize for ListActiveWriteLimitResponse {
9062 #[allow(deprecated)]
9063 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9064 where
9065 S: serde::Serializer,
9066 {
9067 use serde::ser::SerializeStruct;
9068 let mut len = 0;
9069 if !self.write_limits.is_empty() {
9070 len += 1;
9071 }
9072 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
9073 if !self.write_limits.is_empty() {
9074 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
9075 }
9076 struct_ser.end()
9077 }
9078}
9079impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
9080 #[allow(deprecated)]
9081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9082 where
9083 D: serde::Deserializer<'de>,
9084 {
9085 const FIELDS: &[&str] = &[
9086 "write_limits",
9087 "writeLimits",
9088 ];
9089
9090 #[allow(clippy::enum_variant_names)]
9091 enum GeneratedField {
9092 WriteLimits,
9093 }
9094 impl<'de> serde::Deserialize<'de> for GeneratedField {
9095 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9096 where
9097 D: serde::Deserializer<'de>,
9098 {
9099 struct GeneratedVisitor;
9100
9101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9102 type Value = GeneratedField;
9103
9104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9105 write!(formatter, "expected one of: {:?}", &FIELDS)
9106 }
9107
9108 #[allow(unused_variables)]
9109 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9110 where
9111 E: serde::de::Error,
9112 {
9113 match value {
9114 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
9115 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9116 }
9117 }
9118 }
9119 deserializer.deserialize_identifier(GeneratedVisitor)
9120 }
9121 }
9122 struct GeneratedVisitor;
9123 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9124 type Value = ListActiveWriteLimitResponse;
9125
9126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9127 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
9128 }
9129
9130 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
9131 where
9132 V: serde::de::MapAccess<'de>,
9133 {
9134 let mut write_limits__ = None;
9135 while let Some(k) = map_.next_key()? {
9136 match k {
9137 GeneratedField::WriteLimits => {
9138 if write_limits__.is_some() {
9139 return Err(serde::de::Error::duplicate_field("writeLimits"));
9140 }
9141 write_limits__ = Some(
9142 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
9143 .into_iter().map(|(k,v)| (k.0, v)).collect()
9144 );
9145 }
9146 }
9147 }
9148 Ok(ListActiveWriteLimitResponse {
9149 write_limits: write_limits__.unwrap_or_default(),
9150 })
9151 }
9152 }
9153 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
9154 }
9155}
9156impl serde::Serialize for ListBranchedObjectRequest {
9157 #[allow(deprecated)]
9158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9159 where
9160 S: serde::Serializer,
9161 {
9162 use serde::ser::SerializeStruct;
9163 let len = 0;
9164 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
9165 struct_ser.end()
9166 }
9167}
9168impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
9169 #[allow(deprecated)]
9170 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9171 where
9172 D: serde::Deserializer<'de>,
9173 {
9174 const FIELDS: &[&str] = &[
9175 ];
9176
9177 #[allow(clippy::enum_variant_names)]
9178 enum GeneratedField {
9179 }
9180 impl<'de> serde::Deserialize<'de> for GeneratedField {
9181 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9182 where
9183 D: serde::Deserializer<'de>,
9184 {
9185 struct GeneratedVisitor;
9186
9187 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9188 type Value = GeneratedField;
9189
9190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9191 write!(formatter, "expected one of: {:?}", &FIELDS)
9192 }
9193
9194 #[allow(unused_variables)]
9195 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9196 where
9197 E: serde::de::Error,
9198 {
9199 Err(serde::de::Error::unknown_field(value, FIELDS))
9200 }
9201 }
9202 deserializer.deserialize_identifier(GeneratedVisitor)
9203 }
9204 }
9205 struct GeneratedVisitor;
9206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9207 type Value = ListBranchedObjectRequest;
9208
9209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9210 formatter.write_str("struct hummock.ListBranchedObjectRequest")
9211 }
9212
9213 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
9214 where
9215 V: serde::de::MapAccess<'de>,
9216 {
9217 while map_.next_key::<GeneratedField>()?.is_some() {
9218 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9219 }
9220 Ok(ListBranchedObjectRequest {
9221 })
9222 }
9223 }
9224 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
9225 }
9226}
9227impl serde::Serialize for ListBranchedObjectResponse {
9228 #[allow(deprecated)]
9229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9230 where
9231 S: serde::Serializer,
9232 {
9233 use serde::ser::SerializeStruct;
9234 let mut len = 0;
9235 if !self.branched_objects.is_empty() {
9236 len += 1;
9237 }
9238 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
9239 if !self.branched_objects.is_empty() {
9240 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
9241 }
9242 struct_ser.end()
9243 }
9244}
9245impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
9246 #[allow(deprecated)]
9247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9248 where
9249 D: serde::Deserializer<'de>,
9250 {
9251 const FIELDS: &[&str] = &[
9252 "branched_objects",
9253 "branchedObjects",
9254 ];
9255
9256 #[allow(clippy::enum_variant_names)]
9257 enum GeneratedField {
9258 BranchedObjects,
9259 }
9260 impl<'de> serde::Deserialize<'de> for GeneratedField {
9261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9262 where
9263 D: serde::Deserializer<'de>,
9264 {
9265 struct GeneratedVisitor;
9266
9267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9268 type Value = GeneratedField;
9269
9270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9271 write!(formatter, "expected one of: {:?}", &FIELDS)
9272 }
9273
9274 #[allow(unused_variables)]
9275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9276 where
9277 E: serde::de::Error,
9278 {
9279 match value {
9280 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
9281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9282 }
9283 }
9284 }
9285 deserializer.deserialize_identifier(GeneratedVisitor)
9286 }
9287 }
9288 struct GeneratedVisitor;
9289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9290 type Value = ListBranchedObjectResponse;
9291
9292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9293 formatter.write_str("struct hummock.ListBranchedObjectResponse")
9294 }
9295
9296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
9297 where
9298 V: serde::de::MapAccess<'de>,
9299 {
9300 let mut branched_objects__ = None;
9301 while let Some(k) = map_.next_key()? {
9302 match k {
9303 GeneratedField::BranchedObjects => {
9304 if branched_objects__.is_some() {
9305 return Err(serde::de::Error::duplicate_field("branchedObjects"));
9306 }
9307 branched_objects__ = Some(map_.next_value()?);
9308 }
9309 }
9310 }
9311 Ok(ListBranchedObjectResponse {
9312 branched_objects: branched_objects__.unwrap_or_default(),
9313 })
9314 }
9315 }
9316 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
9317 }
9318}
9319impl serde::Serialize for ListCompactTaskAssignmentRequest {
9320 #[allow(deprecated)]
9321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9322 where
9323 S: serde::Serializer,
9324 {
9325 use serde::ser::SerializeStruct;
9326 let len = 0;
9327 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
9328 struct_ser.end()
9329 }
9330}
9331impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
9332 #[allow(deprecated)]
9333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9334 where
9335 D: serde::Deserializer<'de>,
9336 {
9337 const FIELDS: &[&str] = &[
9338 ];
9339
9340 #[allow(clippy::enum_variant_names)]
9341 enum GeneratedField {
9342 }
9343 impl<'de> serde::Deserialize<'de> for GeneratedField {
9344 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9345 where
9346 D: serde::Deserializer<'de>,
9347 {
9348 struct GeneratedVisitor;
9349
9350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9351 type Value = GeneratedField;
9352
9353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9354 write!(formatter, "expected one of: {:?}", &FIELDS)
9355 }
9356
9357 #[allow(unused_variables)]
9358 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9359 where
9360 E: serde::de::Error,
9361 {
9362 Err(serde::de::Error::unknown_field(value, FIELDS))
9363 }
9364 }
9365 deserializer.deserialize_identifier(GeneratedVisitor)
9366 }
9367 }
9368 struct GeneratedVisitor;
9369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9370 type Value = ListCompactTaskAssignmentRequest;
9371
9372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9373 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
9374 }
9375
9376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
9377 where
9378 V: serde::de::MapAccess<'de>,
9379 {
9380 while map_.next_key::<GeneratedField>()?.is_some() {
9381 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9382 }
9383 Ok(ListCompactTaskAssignmentRequest {
9384 })
9385 }
9386 }
9387 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
9388 }
9389}
9390impl serde::Serialize for ListCompactTaskAssignmentResponse {
9391 #[allow(deprecated)]
9392 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9393 where
9394 S: serde::Serializer,
9395 {
9396 use serde::ser::SerializeStruct;
9397 let mut len = 0;
9398 if !self.task_assignment.is_empty() {
9399 len += 1;
9400 }
9401 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
9402 if !self.task_assignment.is_empty() {
9403 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
9404 }
9405 struct_ser.end()
9406 }
9407}
9408impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
9409 #[allow(deprecated)]
9410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9411 where
9412 D: serde::Deserializer<'de>,
9413 {
9414 const FIELDS: &[&str] = &[
9415 "task_assignment",
9416 "taskAssignment",
9417 ];
9418
9419 #[allow(clippy::enum_variant_names)]
9420 enum GeneratedField {
9421 TaskAssignment,
9422 }
9423 impl<'de> serde::Deserialize<'de> for GeneratedField {
9424 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9425 where
9426 D: serde::Deserializer<'de>,
9427 {
9428 struct GeneratedVisitor;
9429
9430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9431 type Value = GeneratedField;
9432
9433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9434 write!(formatter, "expected one of: {:?}", &FIELDS)
9435 }
9436
9437 #[allow(unused_variables)]
9438 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9439 where
9440 E: serde::de::Error,
9441 {
9442 match value {
9443 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
9444 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9445 }
9446 }
9447 }
9448 deserializer.deserialize_identifier(GeneratedVisitor)
9449 }
9450 }
9451 struct GeneratedVisitor;
9452 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9453 type Value = ListCompactTaskAssignmentResponse;
9454
9455 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9456 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
9457 }
9458
9459 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
9460 where
9461 V: serde::de::MapAccess<'de>,
9462 {
9463 let mut task_assignment__ = None;
9464 while let Some(k) = map_.next_key()? {
9465 match k {
9466 GeneratedField::TaskAssignment => {
9467 if task_assignment__.is_some() {
9468 return Err(serde::de::Error::duplicate_field("taskAssignment"));
9469 }
9470 task_assignment__ = Some(map_.next_value()?);
9471 }
9472 }
9473 }
9474 Ok(ListCompactTaskAssignmentResponse {
9475 task_assignment: task_assignment__.unwrap_or_default(),
9476 })
9477 }
9478 }
9479 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
9480 }
9481}
9482impl serde::Serialize for ListCompactTaskProgressRequest {
9483 #[allow(deprecated)]
9484 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9485 where
9486 S: serde::Serializer,
9487 {
9488 use serde::ser::SerializeStruct;
9489 let len = 0;
9490 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
9491 struct_ser.end()
9492 }
9493}
9494impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
9495 #[allow(deprecated)]
9496 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9497 where
9498 D: serde::Deserializer<'de>,
9499 {
9500 const FIELDS: &[&str] = &[
9501 ];
9502
9503 #[allow(clippy::enum_variant_names)]
9504 enum GeneratedField {
9505 }
9506 impl<'de> serde::Deserialize<'de> for GeneratedField {
9507 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9508 where
9509 D: serde::Deserializer<'de>,
9510 {
9511 struct GeneratedVisitor;
9512
9513 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9514 type Value = GeneratedField;
9515
9516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9517 write!(formatter, "expected one of: {:?}", &FIELDS)
9518 }
9519
9520 #[allow(unused_variables)]
9521 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9522 where
9523 E: serde::de::Error,
9524 {
9525 Err(serde::de::Error::unknown_field(value, FIELDS))
9526 }
9527 }
9528 deserializer.deserialize_identifier(GeneratedVisitor)
9529 }
9530 }
9531 struct GeneratedVisitor;
9532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9533 type Value = ListCompactTaskProgressRequest;
9534
9535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9536 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
9537 }
9538
9539 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
9540 where
9541 V: serde::de::MapAccess<'de>,
9542 {
9543 while map_.next_key::<GeneratedField>()?.is_some() {
9544 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9545 }
9546 Ok(ListCompactTaskProgressRequest {
9547 })
9548 }
9549 }
9550 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
9551 }
9552}
9553impl serde::Serialize for ListCompactTaskProgressResponse {
9554 #[allow(deprecated)]
9555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9556 where
9557 S: serde::Serializer,
9558 {
9559 use serde::ser::SerializeStruct;
9560 let mut len = 0;
9561 if !self.task_progress.is_empty() {
9562 len += 1;
9563 }
9564 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
9565 if !self.task_progress.is_empty() {
9566 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
9567 }
9568 struct_ser.end()
9569 }
9570}
9571impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
9572 #[allow(deprecated)]
9573 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9574 where
9575 D: serde::Deserializer<'de>,
9576 {
9577 const FIELDS: &[&str] = &[
9578 "task_progress",
9579 "taskProgress",
9580 ];
9581
9582 #[allow(clippy::enum_variant_names)]
9583 enum GeneratedField {
9584 TaskProgress,
9585 }
9586 impl<'de> serde::Deserialize<'de> for GeneratedField {
9587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9588 where
9589 D: serde::Deserializer<'de>,
9590 {
9591 struct GeneratedVisitor;
9592
9593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9594 type Value = GeneratedField;
9595
9596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9597 write!(formatter, "expected one of: {:?}", &FIELDS)
9598 }
9599
9600 #[allow(unused_variables)]
9601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9602 where
9603 E: serde::de::Error,
9604 {
9605 match value {
9606 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
9607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9608 }
9609 }
9610 }
9611 deserializer.deserialize_identifier(GeneratedVisitor)
9612 }
9613 }
9614 struct GeneratedVisitor;
9615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9616 type Value = ListCompactTaskProgressResponse;
9617
9618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9619 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
9620 }
9621
9622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
9623 where
9624 V: serde::de::MapAccess<'de>,
9625 {
9626 let mut task_progress__ = None;
9627 while let Some(k) = map_.next_key()? {
9628 match k {
9629 GeneratedField::TaskProgress => {
9630 if task_progress__.is_some() {
9631 return Err(serde::de::Error::duplicate_field("taskProgress"));
9632 }
9633 task_progress__ = Some(map_.next_value()?);
9634 }
9635 }
9636 }
9637 Ok(ListCompactTaskProgressResponse {
9638 task_progress: task_progress__.unwrap_or_default(),
9639 })
9640 }
9641 }
9642 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
9643 }
9644}
9645impl serde::Serialize for ListHummockMetaConfigRequest {
9646 #[allow(deprecated)]
9647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9648 where
9649 S: serde::Serializer,
9650 {
9651 use serde::ser::SerializeStruct;
9652 let len = 0;
9653 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
9654 struct_ser.end()
9655 }
9656}
9657impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
9658 #[allow(deprecated)]
9659 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9660 where
9661 D: serde::Deserializer<'de>,
9662 {
9663 const FIELDS: &[&str] = &[
9664 ];
9665
9666 #[allow(clippy::enum_variant_names)]
9667 enum GeneratedField {
9668 }
9669 impl<'de> serde::Deserialize<'de> for GeneratedField {
9670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9671 where
9672 D: serde::Deserializer<'de>,
9673 {
9674 struct GeneratedVisitor;
9675
9676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9677 type Value = GeneratedField;
9678
9679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9680 write!(formatter, "expected one of: {:?}", &FIELDS)
9681 }
9682
9683 #[allow(unused_variables)]
9684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9685 where
9686 E: serde::de::Error,
9687 {
9688 Err(serde::de::Error::unknown_field(value, FIELDS))
9689 }
9690 }
9691 deserializer.deserialize_identifier(GeneratedVisitor)
9692 }
9693 }
9694 struct GeneratedVisitor;
9695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9696 type Value = ListHummockMetaConfigRequest;
9697
9698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9699 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
9700 }
9701
9702 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
9703 where
9704 V: serde::de::MapAccess<'de>,
9705 {
9706 while map_.next_key::<GeneratedField>()?.is_some() {
9707 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9708 }
9709 Ok(ListHummockMetaConfigRequest {
9710 })
9711 }
9712 }
9713 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
9714 }
9715}
9716impl serde::Serialize for ListHummockMetaConfigResponse {
9717 #[allow(deprecated)]
9718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9719 where
9720 S: serde::Serializer,
9721 {
9722 use serde::ser::SerializeStruct;
9723 let mut len = 0;
9724 if !self.configs.is_empty() {
9725 len += 1;
9726 }
9727 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
9728 if !self.configs.is_empty() {
9729 struct_ser.serialize_field("configs", &self.configs)?;
9730 }
9731 struct_ser.end()
9732 }
9733}
9734impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
9735 #[allow(deprecated)]
9736 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9737 where
9738 D: serde::Deserializer<'de>,
9739 {
9740 const FIELDS: &[&str] = &[
9741 "configs",
9742 ];
9743
9744 #[allow(clippy::enum_variant_names)]
9745 enum GeneratedField {
9746 Configs,
9747 }
9748 impl<'de> serde::Deserialize<'de> for GeneratedField {
9749 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9750 where
9751 D: serde::Deserializer<'de>,
9752 {
9753 struct GeneratedVisitor;
9754
9755 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9756 type Value = GeneratedField;
9757
9758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9759 write!(formatter, "expected one of: {:?}", &FIELDS)
9760 }
9761
9762 #[allow(unused_variables)]
9763 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9764 where
9765 E: serde::de::Error,
9766 {
9767 match value {
9768 "configs" => Ok(GeneratedField::Configs),
9769 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9770 }
9771 }
9772 }
9773 deserializer.deserialize_identifier(GeneratedVisitor)
9774 }
9775 }
9776 struct GeneratedVisitor;
9777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9778 type Value = ListHummockMetaConfigResponse;
9779
9780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9781 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
9782 }
9783
9784 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
9785 where
9786 V: serde::de::MapAccess<'de>,
9787 {
9788 let mut configs__ = None;
9789 while let Some(k) = map_.next_key()? {
9790 match k {
9791 GeneratedField::Configs => {
9792 if configs__.is_some() {
9793 return Err(serde::de::Error::duplicate_field("configs"));
9794 }
9795 configs__ = Some(
9796 map_.next_value::<std::collections::HashMap<_, _>>()?
9797 );
9798 }
9799 }
9800 }
9801 Ok(ListHummockMetaConfigResponse {
9802 configs: configs__.unwrap_or_default(),
9803 })
9804 }
9805 }
9806 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
9807 }
9808}
9809impl serde::Serialize for ListVersionDeltasRequest {
9810 #[allow(deprecated)]
9811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9812 where
9813 S: serde::Serializer,
9814 {
9815 use serde::ser::SerializeStruct;
9816 let mut len = 0;
9817 if self.start_id != 0 {
9818 len += 1;
9819 }
9820 if self.num_limit != 0 {
9821 len += 1;
9822 }
9823 if self.committed_epoch_limit != 0 {
9824 len += 1;
9825 }
9826 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
9827 if self.start_id != 0 {
9828 #[allow(clippy::needless_borrow)]
9829 #[allow(clippy::needless_borrows_for_generic_args)]
9830 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
9831 }
9832 if self.num_limit != 0 {
9833 struct_ser.serialize_field("numLimit", &self.num_limit)?;
9834 }
9835 if self.committed_epoch_limit != 0 {
9836 #[allow(clippy::needless_borrow)]
9837 #[allow(clippy::needless_borrows_for_generic_args)]
9838 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
9839 }
9840 struct_ser.end()
9841 }
9842}
9843impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
9844 #[allow(deprecated)]
9845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9846 where
9847 D: serde::Deserializer<'de>,
9848 {
9849 const FIELDS: &[&str] = &[
9850 "start_id",
9851 "startId",
9852 "num_limit",
9853 "numLimit",
9854 "committed_epoch_limit",
9855 "committedEpochLimit",
9856 ];
9857
9858 #[allow(clippy::enum_variant_names)]
9859 enum GeneratedField {
9860 StartId,
9861 NumLimit,
9862 CommittedEpochLimit,
9863 }
9864 impl<'de> serde::Deserialize<'de> for GeneratedField {
9865 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9866 where
9867 D: serde::Deserializer<'de>,
9868 {
9869 struct GeneratedVisitor;
9870
9871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9872 type Value = GeneratedField;
9873
9874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9875 write!(formatter, "expected one of: {:?}", &FIELDS)
9876 }
9877
9878 #[allow(unused_variables)]
9879 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9880 where
9881 E: serde::de::Error,
9882 {
9883 match value {
9884 "startId" | "start_id" => Ok(GeneratedField::StartId),
9885 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
9886 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
9887 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9888 }
9889 }
9890 }
9891 deserializer.deserialize_identifier(GeneratedVisitor)
9892 }
9893 }
9894 struct GeneratedVisitor;
9895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9896 type Value = ListVersionDeltasRequest;
9897
9898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9899 formatter.write_str("struct hummock.ListVersionDeltasRequest")
9900 }
9901
9902 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
9903 where
9904 V: serde::de::MapAccess<'de>,
9905 {
9906 let mut start_id__ = None;
9907 let mut num_limit__ = None;
9908 let mut committed_epoch_limit__ = None;
9909 while let Some(k) = map_.next_key()? {
9910 match k {
9911 GeneratedField::StartId => {
9912 if start_id__.is_some() {
9913 return Err(serde::de::Error::duplicate_field("startId"));
9914 }
9915 start_id__ =
9916 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9917 ;
9918 }
9919 GeneratedField::NumLimit => {
9920 if num_limit__.is_some() {
9921 return Err(serde::de::Error::duplicate_field("numLimit"));
9922 }
9923 num_limit__ =
9924 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9925 ;
9926 }
9927 GeneratedField::CommittedEpochLimit => {
9928 if committed_epoch_limit__.is_some() {
9929 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
9930 }
9931 committed_epoch_limit__ =
9932 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9933 ;
9934 }
9935 }
9936 }
9937 Ok(ListVersionDeltasRequest {
9938 start_id: start_id__.unwrap_or_default(),
9939 num_limit: num_limit__.unwrap_or_default(),
9940 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
9941 })
9942 }
9943 }
9944 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
9945 }
9946}
9947impl serde::Serialize for ListVersionDeltasResponse {
9948 #[allow(deprecated)]
9949 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9950 where
9951 S: serde::Serializer,
9952 {
9953 use serde::ser::SerializeStruct;
9954 let mut len = 0;
9955 if self.version_deltas.is_some() {
9956 len += 1;
9957 }
9958 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
9959 if let Some(v) = self.version_deltas.as_ref() {
9960 struct_ser.serialize_field("versionDeltas", v)?;
9961 }
9962 struct_ser.end()
9963 }
9964}
9965impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
9966 #[allow(deprecated)]
9967 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9968 where
9969 D: serde::Deserializer<'de>,
9970 {
9971 const FIELDS: &[&str] = &[
9972 "version_deltas",
9973 "versionDeltas",
9974 ];
9975
9976 #[allow(clippy::enum_variant_names)]
9977 enum GeneratedField {
9978 VersionDeltas,
9979 }
9980 impl<'de> serde::Deserialize<'de> for GeneratedField {
9981 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9982 where
9983 D: serde::Deserializer<'de>,
9984 {
9985 struct GeneratedVisitor;
9986
9987 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9988 type Value = GeneratedField;
9989
9990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9991 write!(formatter, "expected one of: {:?}", &FIELDS)
9992 }
9993
9994 #[allow(unused_variables)]
9995 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9996 where
9997 E: serde::de::Error,
9998 {
9999 match value {
10000 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
10001 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10002 }
10003 }
10004 }
10005 deserializer.deserialize_identifier(GeneratedVisitor)
10006 }
10007 }
10008 struct GeneratedVisitor;
10009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10010 type Value = ListVersionDeltasResponse;
10011
10012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10013 formatter.write_str("struct hummock.ListVersionDeltasResponse")
10014 }
10015
10016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
10017 where
10018 V: serde::de::MapAccess<'de>,
10019 {
10020 let mut version_deltas__ = None;
10021 while let Some(k) = map_.next_key()? {
10022 match k {
10023 GeneratedField::VersionDeltas => {
10024 if version_deltas__.is_some() {
10025 return Err(serde::de::Error::duplicate_field("versionDeltas"));
10026 }
10027 version_deltas__ = map_.next_value()?;
10028 }
10029 }
10030 }
10031 Ok(ListVersionDeltasResponse {
10032 version_deltas: version_deltas__,
10033 })
10034 }
10035 }
10036 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
10037 }
10038}
10039impl serde::Serialize for MergeCompactionGroupRequest {
10040 #[allow(deprecated)]
10041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10042 where
10043 S: serde::Serializer,
10044 {
10045 use serde::ser::SerializeStruct;
10046 let mut len = 0;
10047 if self.left_group_id != 0 {
10048 len += 1;
10049 }
10050 if self.right_group_id != 0 {
10051 len += 1;
10052 }
10053 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
10054 if self.left_group_id != 0 {
10055 #[allow(clippy::needless_borrow)]
10056 #[allow(clippy::needless_borrows_for_generic_args)]
10057 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
10058 }
10059 if self.right_group_id != 0 {
10060 #[allow(clippy::needless_borrow)]
10061 #[allow(clippy::needless_borrows_for_generic_args)]
10062 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
10063 }
10064 struct_ser.end()
10065 }
10066}
10067impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
10068 #[allow(deprecated)]
10069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10070 where
10071 D: serde::Deserializer<'de>,
10072 {
10073 const FIELDS: &[&str] = &[
10074 "left_group_id",
10075 "leftGroupId",
10076 "right_group_id",
10077 "rightGroupId",
10078 ];
10079
10080 #[allow(clippy::enum_variant_names)]
10081 enum GeneratedField {
10082 LeftGroupId,
10083 RightGroupId,
10084 }
10085 impl<'de> serde::Deserialize<'de> for GeneratedField {
10086 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10087 where
10088 D: serde::Deserializer<'de>,
10089 {
10090 struct GeneratedVisitor;
10091
10092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10093 type Value = GeneratedField;
10094
10095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10096 write!(formatter, "expected one of: {:?}", &FIELDS)
10097 }
10098
10099 #[allow(unused_variables)]
10100 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10101 where
10102 E: serde::de::Error,
10103 {
10104 match value {
10105 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
10106 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
10107 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10108 }
10109 }
10110 }
10111 deserializer.deserialize_identifier(GeneratedVisitor)
10112 }
10113 }
10114 struct GeneratedVisitor;
10115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10116 type Value = MergeCompactionGroupRequest;
10117
10118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10119 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
10120 }
10121
10122 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
10123 where
10124 V: serde::de::MapAccess<'de>,
10125 {
10126 let mut left_group_id__ = None;
10127 let mut right_group_id__ = None;
10128 while let Some(k) = map_.next_key()? {
10129 match k {
10130 GeneratedField::LeftGroupId => {
10131 if left_group_id__.is_some() {
10132 return Err(serde::de::Error::duplicate_field("leftGroupId"));
10133 }
10134 left_group_id__ =
10135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10136 ;
10137 }
10138 GeneratedField::RightGroupId => {
10139 if right_group_id__.is_some() {
10140 return Err(serde::de::Error::duplicate_field("rightGroupId"));
10141 }
10142 right_group_id__ =
10143 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10144 ;
10145 }
10146 }
10147 }
10148 Ok(MergeCompactionGroupRequest {
10149 left_group_id: left_group_id__.unwrap_or_default(),
10150 right_group_id: right_group_id__.unwrap_or_default(),
10151 })
10152 }
10153 }
10154 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
10155 }
10156}
10157impl serde::Serialize for MergeCompactionGroupResponse {
10158 #[allow(deprecated)]
10159 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10160 where
10161 S: serde::Serializer,
10162 {
10163 use serde::ser::SerializeStruct;
10164 let len = 0;
10165 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
10166 struct_ser.end()
10167 }
10168}
10169impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
10170 #[allow(deprecated)]
10171 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10172 where
10173 D: serde::Deserializer<'de>,
10174 {
10175 const FIELDS: &[&str] = &[
10176 ];
10177
10178 #[allow(clippy::enum_variant_names)]
10179 enum GeneratedField {
10180 }
10181 impl<'de> serde::Deserialize<'de> for GeneratedField {
10182 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10183 where
10184 D: serde::Deserializer<'de>,
10185 {
10186 struct GeneratedVisitor;
10187
10188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10189 type Value = GeneratedField;
10190
10191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10192 write!(formatter, "expected one of: {:?}", &FIELDS)
10193 }
10194
10195 #[allow(unused_variables)]
10196 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10197 where
10198 E: serde::de::Error,
10199 {
10200 Err(serde::de::Error::unknown_field(value, FIELDS))
10201 }
10202 }
10203 deserializer.deserialize_identifier(GeneratedVisitor)
10204 }
10205 }
10206 struct GeneratedVisitor;
10207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10208 type Value = MergeCompactionGroupResponse;
10209
10210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10211 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
10212 }
10213
10214 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
10215 where
10216 V: serde::de::MapAccess<'de>,
10217 {
10218 while map_.next_key::<GeneratedField>()?.is_some() {
10219 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10220 }
10221 Ok(MergeCompactionGroupResponse {
10222 })
10223 }
10224 }
10225 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
10226 }
10227}
10228impl serde::Serialize for NewL0SubLevel {
10229 #[allow(deprecated)]
10230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10231 where
10232 S: serde::Serializer,
10233 {
10234 use serde::ser::SerializeStruct;
10235 let mut len = 0;
10236 if !self.inserted_table_infos.is_empty() {
10237 len += 1;
10238 }
10239 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
10240 if !self.inserted_table_infos.is_empty() {
10241 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
10242 }
10243 struct_ser.end()
10244 }
10245}
10246impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
10247 #[allow(deprecated)]
10248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10249 where
10250 D: serde::Deserializer<'de>,
10251 {
10252 const FIELDS: &[&str] = &[
10253 "inserted_table_infos",
10254 "insertedTableInfos",
10255 ];
10256
10257 #[allow(clippy::enum_variant_names)]
10258 enum GeneratedField {
10259 InsertedTableInfos,
10260 }
10261 impl<'de> serde::Deserialize<'de> for GeneratedField {
10262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10263 where
10264 D: serde::Deserializer<'de>,
10265 {
10266 struct GeneratedVisitor;
10267
10268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10269 type Value = GeneratedField;
10270
10271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10272 write!(formatter, "expected one of: {:?}", &FIELDS)
10273 }
10274
10275 #[allow(unused_variables)]
10276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10277 where
10278 E: serde::de::Error,
10279 {
10280 match value {
10281 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
10282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10283 }
10284 }
10285 }
10286 deserializer.deserialize_identifier(GeneratedVisitor)
10287 }
10288 }
10289 struct GeneratedVisitor;
10290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10291 type Value = NewL0SubLevel;
10292
10293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10294 formatter.write_str("struct hummock.NewL0SubLevel")
10295 }
10296
10297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
10298 where
10299 V: serde::de::MapAccess<'de>,
10300 {
10301 let mut inserted_table_infos__ = None;
10302 while let Some(k) = map_.next_key()? {
10303 match k {
10304 GeneratedField::InsertedTableInfos => {
10305 if inserted_table_infos__.is_some() {
10306 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
10307 }
10308 inserted_table_infos__ = Some(map_.next_value()?);
10309 }
10310 }
10311 }
10312 Ok(NewL0SubLevel {
10313 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
10314 })
10315 }
10316 }
10317 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
10318 }
10319}
10320impl serde::Serialize for OverlappingLevel {
10321 #[allow(deprecated)]
10322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10323 where
10324 S: serde::Serializer,
10325 {
10326 use serde::ser::SerializeStruct;
10327 let mut len = 0;
10328 if !self.sub_levels.is_empty() {
10329 len += 1;
10330 }
10331 if self.total_file_size != 0 {
10332 len += 1;
10333 }
10334 if self.uncompressed_file_size != 0 {
10335 len += 1;
10336 }
10337 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
10338 if !self.sub_levels.is_empty() {
10339 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
10340 }
10341 if self.total_file_size != 0 {
10342 #[allow(clippy::needless_borrow)]
10343 #[allow(clippy::needless_borrows_for_generic_args)]
10344 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
10345 }
10346 if self.uncompressed_file_size != 0 {
10347 #[allow(clippy::needless_borrow)]
10348 #[allow(clippy::needless_borrows_for_generic_args)]
10349 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
10350 }
10351 struct_ser.end()
10352 }
10353}
10354impl<'de> serde::Deserialize<'de> for OverlappingLevel {
10355 #[allow(deprecated)]
10356 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10357 where
10358 D: serde::Deserializer<'de>,
10359 {
10360 const FIELDS: &[&str] = &[
10361 "sub_levels",
10362 "subLevels",
10363 "total_file_size",
10364 "totalFileSize",
10365 "uncompressed_file_size",
10366 "uncompressedFileSize",
10367 ];
10368
10369 #[allow(clippy::enum_variant_names)]
10370 enum GeneratedField {
10371 SubLevels,
10372 TotalFileSize,
10373 UncompressedFileSize,
10374 }
10375 impl<'de> serde::Deserialize<'de> for GeneratedField {
10376 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10377 where
10378 D: serde::Deserializer<'de>,
10379 {
10380 struct GeneratedVisitor;
10381
10382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10383 type Value = GeneratedField;
10384
10385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10386 write!(formatter, "expected one of: {:?}", &FIELDS)
10387 }
10388
10389 #[allow(unused_variables)]
10390 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10391 where
10392 E: serde::de::Error,
10393 {
10394 match value {
10395 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
10396 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
10397 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
10398 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10399 }
10400 }
10401 }
10402 deserializer.deserialize_identifier(GeneratedVisitor)
10403 }
10404 }
10405 struct GeneratedVisitor;
10406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10407 type Value = OverlappingLevel;
10408
10409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10410 formatter.write_str("struct hummock.OverlappingLevel")
10411 }
10412
10413 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
10414 where
10415 V: serde::de::MapAccess<'de>,
10416 {
10417 let mut sub_levels__ = None;
10418 let mut total_file_size__ = None;
10419 let mut uncompressed_file_size__ = None;
10420 while let Some(k) = map_.next_key()? {
10421 match k {
10422 GeneratedField::SubLevels => {
10423 if sub_levels__.is_some() {
10424 return Err(serde::de::Error::duplicate_field("subLevels"));
10425 }
10426 sub_levels__ = Some(map_.next_value()?);
10427 }
10428 GeneratedField::TotalFileSize => {
10429 if total_file_size__.is_some() {
10430 return Err(serde::de::Error::duplicate_field("totalFileSize"));
10431 }
10432 total_file_size__ =
10433 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10434 ;
10435 }
10436 GeneratedField::UncompressedFileSize => {
10437 if uncompressed_file_size__.is_some() {
10438 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
10439 }
10440 uncompressed_file_size__ =
10441 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10442 ;
10443 }
10444 }
10445 }
10446 Ok(OverlappingLevel {
10447 sub_levels: sub_levels__.unwrap_or_default(),
10448 total_file_size: total_file_size__.unwrap_or_default(),
10449 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
10450 })
10451 }
10452 }
10453 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
10454 }
10455}
10456impl serde::Serialize for PinVersionRequest {
10457 #[allow(deprecated)]
10458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10459 where
10460 S: serde::Serializer,
10461 {
10462 use serde::ser::SerializeStruct;
10463 let mut len = 0;
10464 if self.context_id != 0 {
10465 len += 1;
10466 }
10467 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
10468 if self.context_id != 0 {
10469 struct_ser.serialize_field("contextId", &self.context_id)?;
10470 }
10471 struct_ser.end()
10472 }
10473}
10474impl<'de> serde::Deserialize<'de> for PinVersionRequest {
10475 #[allow(deprecated)]
10476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10477 where
10478 D: serde::Deserializer<'de>,
10479 {
10480 const FIELDS: &[&str] = &[
10481 "context_id",
10482 "contextId",
10483 ];
10484
10485 #[allow(clippy::enum_variant_names)]
10486 enum GeneratedField {
10487 ContextId,
10488 }
10489 impl<'de> serde::Deserialize<'de> for GeneratedField {
10490 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10491 where
10492 D: serde::Deserializer<'de>,
10493 {
10494 struct GeneratedVisitor;
10495
10496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10497 type Value = GeneratedField;
10498
10499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10500 write!(formatter, "expected one of: {:?}", &FIELDS)
10501 }
10502
10503 #[allow(unused_variables)]
10504 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10505 where
10506 E: serde::de::Error,
10507 {
10508 match value {
10509 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
10510 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10511 }
10512 }
10513 }
10514 deserializer.deserialize_identifier(GeneratedVisitor)
10515 }
10516 }
10517 struct GeneratedVisitor;
10518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10519 type Value = PinVersionRequest;
10520
10521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10522 formatter.write_str("struct hummock.PinVersionRequest")
10523 }
10524
10525 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
10526 where
10527 V: serde::de::MapAccess<'de>,
10528 {
10529 let mut context_id__ = None;
10530 while let Some(k) = map_.next_key()? {
10531 match k {
10532 GeneratedField::ContextId => {
10533 if context_id__.is_some() {
10534 return Err(serde::de::Error::duplicate_field("contextId"));
10535 }
10536 context_id__ =
10537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10538 ;
10539 }
10540 }
10541 }
10542 Ok(PinVersionRequest {
10543 context_id: context_id__.unwrap_or_default(),
10544 })
10545 }
10546 }
10547 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
10548 }
10549}
10550impl serde::Serialize for PinVersionResponse {
10551 #[allow(deprecated)]
10552 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10553 where
10554 S: serde::Serializer,
10555 {
10556 use serde::ser::SerializeStruct;
10557 let mut len = 0;
10558 if self.pinned_version.is_some() {
10559 len += 1;
10560 }
10561 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
10562 if let Some(v) = self.pinned_version.as_ref() {
10563 struct_ser.serialize_field("pinnedVersion", v)?;
10564 }
10565 struct_ser.end()
10566 }
10567}
10568impl<'de> serde::Deserialize<'de> for PinVersionResponse {
10569 #[allow(deprecated)]
10570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10571 where
10572 D: serde::Deserializer<'de>,
10573 {
10574 const FIELDS: &[&str] = &[
10575 "pinned_version",
10576 "pinnedVersion",
10577 ];
10578
10579 #[allow(clippy::enum_variant_names)]
10580 enum GeneratedField {
10581 PinnedVersion,
10582 }
10583 impl<'de> serde::Deserialize<'de> for GeneratedField {
10584 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10585 where
10586 D: serde::Deserializer<'de>,
10587 {
10588 struct GeneratedVisitor;
10589
10590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10591 type Value = GeneratedField;
10592
10593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10594 write!(formatter, "expected one of: {:?}", &FIELDS)
10595 }
10596
10597 #[allow(unused_variables)]
10598 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10599 where
10600 E: serde::de::Error,
10601 {
10602 match value {
10603 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
10604 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10605 }
10606 }
10607 }
10608 deserializer.deserialize_identifier(GeneratedVisitor)
10609 }
10610 }
10611 struct GeneratedVisitor;
10612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10613 type Value = PinVersionResponse;
10614
10615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10616 formatter.write_str("struct hummock.PinVersionResponse")
10617 }
10618
10619 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
10620 where
10621 V: serde::de::MapAccess<'de>,
10622 {
10623 let mut pinned_version__ = None;
10624 while let Some(k) = map_.next_key()? {
10625 match k {
10626 GeneratedField::PinnedVersion => {
10627 if pinned_version__.is_some() {
10628 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
10629 }
10630 pinned_version__ = map_.next_value()?;
10631 }
10632 }
10633 }
10634 Ok(PinVersionResponse {
10635 pinned_version: pinned_version__,
10636 })
10637 }
10638 }
10639 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
10640 }
10641}
10642impl serde::Serialize for PinnedVersionsSummary {
10643 #[allow(deprecated)]
10644 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10645 where
10646 S: serde::Serializer,
10647 {
10648 use serde::ser::SerializeStruct;
10649 let mut len = 0;
10650 if !self.pinned_versions.is_empty() {
10651 len += 1;
10652 }
10653 if !self.workers.is_empty() {
10654 len += 1;
10655 }
10656 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
10657 if !self.pinned_versions.is_empty() {
10658 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
10659 }
10660 if !self.workers.is_empty() {
10661 struct_ser.serialize_field("workers", &self.workers)?;
10662 }
10663 struct_ser.end()
10664 }
10665}
10666impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
10667 #[allow(deprecated)]
10668 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10669 where
10670 D: serde::Deserializer<'de>,
10671 {
10672 const FIELDS: &[&str] = &[
10673 "pinned_versions",
10674 "pinnedVersions",
10675 "workers",
10676 ];
10677
10678 #[allow(clippy::enum_variant_names)]
10679 enum GeneratedField {
10680 PinnedVersions,
10681 Workers,
10682 }
10683 impl<'de> serde::Deserialize<'de> for GeneratedField {
10684 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10685 where
10686 D: serde::Deserializer<'de>,
10687 {
10688 struct GeneratedVisitor;
10689
10690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10691 type Value = GeneratedField;
10692
10693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10694 write!(formatter, "expected one of: {:?}", &FIELDS)
10695 }
10696
10697 #[allow(unused_variables)]
10698 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10699 where
10700 E: serde::de::Error,
10701 {
10702 match value {
10703 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
10704 "workers" => Ok(GeneratedField::Workers),
10705 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10706 }
10707 }
10708 }
10709 deserializer.deserialize_identifier(GeneratedVisitor)
10710 }
10711 }
10712 struct GeneratedVisitor;
10713 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10714 type Value = PinnedVersionsSummary;
10715
10716 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10717 formatter.write_str("struct hummock.PinnedVersionsSummary")
10718 }
10719
10720 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
10721 where
10722 V: serde::de::MapAccess<'de>,
10723 {
10724 let mut pinned_versions__ = None;
10725 let mut workers__ = None;
10726 while let Some(k) = map_.next_key()? {
10727 match k {
10728 GeneratedField::PinnedVersions => {
10729 if pinned_versions__.is_some() {
10730 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
10731 }
10732 pinned_versions__ = Some(map_.next_value()?);
10733 }
10734 GeneratedField::Workers => {
10735 if workers__.is_some() {
10736 return Err(serde::de::Error::duplicate_field("workers"));
10737 }
10738 workers__ = Some(
10739 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10740 .into_iter().map(|(k,v)| (k.0, v)).collect()
10741 );
10742 }
10743 }
10744 }
10745 Ok(PinnedVersionsSummary {
10746 pinned_versions: pinned_versions__.unwrap_or_default(),
10747 workers: workers__.unwrap_or_default(),
10748 })
10749 }
10750 }
10751 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
10752 }
10753}
10754impl serde::Serialize for ReplayVersionDeltaRequest {
10755 #[allow(deprecated)]
10756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10757 where
10758 S: serde::Serializer,
10759 {
10760 use serde::ser::SerializeStruct;
10761 let mut len = 0;
10762 if self.version_delta.is_some() {
10763 len += 1;
10764 }
10765 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
10766 if let Some(v) = self.version_delta.as_ref() {
10767 struct_ser.serialize_field("versionDelta", v)?;
10768 }
10769 struct_ser.end()
10770 }
10771}
10772impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
10773 #[allow(deprecated)]
10774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10775 where
10776 D: serde::Deserializer<'de>,
10777 {
10778 const FIELDS: &[&str] = &[
10779 "version_delta",
10780 "versionDelta",
10781 ];
10782
10783 #[allow(clippy::enum_variant_names)]
10784 enum GeneratedField {
10785 VersionDelta,
10786 }
10787 impl<'de> serde::Deserialize<'de> for GeneratedField {
10788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10789 where
10790 D: serde::Deserializer<'de>,
10791 {
10792 struct GeneratedVisitor;
10793
10794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10795 type Value = GeneratedField;
10796
10797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10798 write!(formatter, "expected one of: {:?}", &FIELDS)
10799 }
10800
10801 #[allow(unused_variables)]
10802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10803 where
10804 E: serde::de::Error,
10805 {
10806 match value {
10807 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
10808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10809 }
10810 }
10811 }
10812 deserializer.deserialize_identifier(GeneratedVisitor)
10813 }
10814 }
10815 struct GeneratedVisitor;
10816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10817 type Value = ReplayVersionDeltaRequest;
10818
10819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10820 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
10821 }
10822
10823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
10824 where
10825 V: serde::de::MapAccess<'de>,
10826 {
10827 let mut version_delta__ = None;
10828 while let Some(k) = map_.next_key()? {
10829 match k {
10830 GeneratedField::VersionDelta => {
10831 if version_delta__.is_some() {
10832 return Err(serde::de::Error::duplicate_field("versionDelta"));
10833 }
10834 version_delta__ = map_.next_value()?;
10835 }
10836 }
10837 }
10838 Ok(ReplayVersionDeltaRequest {
10839 version_delta: version_delta__,
10840 })
10841 }
10842 }
10843 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
10844 }
10845}
10846impl serde::Serialize for ReplayVersionDeltaResponse {
10847 #[allow(deprecated)]
10848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10849 where
10850 S: serde::Serializer,
10851 {
10852 use serde::ser::SerializeStruct;
10853 let mut len = 0;
10854 if self.version.is_some() {
10855 len += 1;
10856 }
10857 if !self.modified_compaction_groups.is_empty() {
10858 len += 1;
10859 }
10860 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
10861 if let Some(v) = self.version.as_ref() {
10862 struct_ser.serialize_field("version", v)?;
10863 }
10864 if !self.modified_compaction_groups.is_empty() {
10865 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
10866 }
10867 struct_ser.end()
10868 }
10869}
10870impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
10871 #[allow(deprecated)]
10872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10873 where
10874 D: serde::Deserializer<'de>,
10875 {
10876 const FIELDS: &[&str] = &[
10877 "version",
10878 "modified_compaction_groups",
10879 "modifiedCompactionGroups",
10880 ];
10881
10882 #[allow(clippy::enum_variant_names)]
10883 enum GeneratedField {
10884 Version,
10885 ModifiedCompactionGroups,
10886 }
10887 impl<'de> serde::Deserialize<'de> for GeneratedField {
10888 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10889 where
10890 D: serde::Deserializer<'de>,
10891 {
10892 struct GeneratedVisitor;
10893
10894 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10895 type Value = GeneratedField;
10896
10897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10898 write!(formatter, "expected one of: {:?}", &FIELDS)
10899 }
10900
10901 #[allow(unused_variables)]
10902 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10903 where
10904 E: serde::de::Error,
10905 {
10906 match value {
10907 "version" => Ok(GeneratedField::Version),
10908 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
10909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10910 }
10911 }
10912 }
10913 deserializer.deserialize_identifier(GeneratedVisitor)
10914 }
10915 }
10916 struct GeneratedVisitor;
10917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10918 type Value = ReplayVersionDeltaResponse;
10919
10920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10921 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
10922 }
10923
10924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
10925 where
10926 V: serde::de::MapAccess<'de>,
10927 {
10928 let mut version__ = None;
10929 let mut modified_compaction_groups__ = None;
10930 while let Some(k) = map_.next_key()? {
10931 match k {
10932 GeneratedField::Version => {
10933 if version__.is_some() {
10934 return Err(serde::de::Error::duplicate_field("version"));
10935 }
10936 version__ = map_.next_value()?;
10937 }
10938 GeneratedField::ModifiedCompactionGroups => {
10939 if modified_compaction_groups__.is_some() {
10940 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
10941 }
10942 modified_compaction_groups__ =
10943 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10944 .into_iter().map(|x| x.0).collect())
10945 ;
10946 }
10947 }
10948 }
10949 Ok(ReplayVersionDeltaResponse {
10950 version: version__,
10951 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
10952 })
10953 }
10954 }
10955 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
10956 }
10957}
10958impl serde::Serialize for ReportCompactionTaskRequest {
10959 #[allow(deprecated)]
10960 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10961 where
10962 S: serde::Serializer,
10963 {
10964 use serde::ser::SerializeStruct;
10965 let mut len = 0;
10966 if self.event.is_some() {
10967 len += 1;
10968 }
10969 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
10970 if let Some(v) = self.event.as_ref() {
10971 match v {
10972 report_compaction_task_request::Event::ReportTask(v) => {
10973 struct_ser.serialize_field("reportTask", v)?;
10974 }
10975 report_compaction_task_request::Event::HeartBeat(v) => {
10976 struct_ser.serialize_field("heartBeat", v)?;
10977 }
10978 }
10979 }
10980 struct_ser.end()
10981 }
10982}
10983impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
10984 #[allow(deprecated)]
10985 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10986 where
10987 D: serde::Deserializer<'de>,
10988 {
10989 const FIELDS: &[&str] = &[
10990 "report_task",
10991 "reportTask",
10992 "heart_beat",
10993 "heartBeat",
10994 ];
10995
10996 #[allow(clippy::enum_variant_names)]
10997 enum GeneratedField {
10998 ReportTask,
10999 HeartBeat,
11000 }
11001 impl<'de> serde::Deserialize<'de> for GeneratedField {
11002 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11003 where
11004 D: serde::Deserializer<'de>,
11005 {
11006 struct GeneratedVisitor;
11007
11008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11009 type Value = GeneratedField;
11010
11011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11012 write!(formatter, "expected one of: {:?}", &FIELDS)
11013 }
11014
11015 #[allow(unused_variables)]
11016 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11017 where
11018 E: serde::de::Error,
11019 {
11020 match value {
11021 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
11022 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
11023 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11024 }
11025 }
11026 }
11027 deserializer.deserialize_identifier(GeneratedVisitor)
11028 }
11029 }
11030 struct GeneratedVisitor;
11031 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11032 type Value = ReportCompactionTaskRequest;
11033
11034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11035 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
11036 }
11037
11038 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
11039 where
11040 V: serde::de::MapAccess<'de>,
11041 {
11042 let mut event__ = None;
11043 while let Some(k) = map_.next_key()? {
11044 match k {
11045 GeneratedField::ReportTask => {
11046 if event__.is_some() {
11047 return Err(serde::de::Error::duplicate_field("reportTask"));
11048 }
11049 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
11050;
11051 }
11052 GeneratedField::HeartBeat => {
11053 if event__.is_some() {
11054 return Err(serde::de::Error::duplicate_field("heartBeat"));
11055 }
11056 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
11057;
11058 }
11059 }
11060 }
11061 Ok(ReportCompactionTaskRequest {
11062 event: event__,
11063 })
11064 }
11065 }
11066 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
11067 }
11068}
11069impl serde::Serialize for report_compaction_task_request::HeartBeat {
11070 #[allow(deprecated)]
11071 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11072 where
11073 S: serde::Serializer,
11074 {
11075 use serde::ser::SerializeStruct;
11076 let mut len = 0;
11077 if !self.progress.is_empty() {
11078 len += 1;
11079 }
11080 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
11081 if !self.progress.is_empty() {
11082 struct_ser.serialize_field("progress", &self.progress)?;
11083 }
11084 struct_ser.end()
11085 }
11086}
11087impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
11088 #[allow(deprecated)]
11089 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11090 where
11091 D: serde::Deserializer<'de>,
11092 {
11093 const FIELDS: &[&str] = &[
11094 "progress",
11095 ];
11096
11097 #[allow(clippy::enum_variant_names)]
11098 enum GeneratedField {
11099 Progress,
11100 }
11101 impl<'de> serde::Deserialize<'de> for GeneratedField {
11102 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11103 where
11104 D: serde::Deserializer<'de>,
11105 {
11106 struct GeneratedVisitor;
11107
11108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11109 type Value = GeneratedField;
11110
11111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11112 write!(formatter, "expected one of: {:?}", &FIELDS)
11113 }
11114
11115 #[allow(unused_variables)]
11116 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11117 where
11118 E: serde::de::Error,
11119 {
11120 match value {
11121 "progress" => Ok(GeneratedField::Progress),
11122 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11123 }
11124 }
11125 }
11126 deserializer.deserialize_identifier(GeneratedVisitor)
11127 }
11128 }
11129 struct GeneratedVisitor;
11130 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11131 type Value = report_compaction_task_request::HeartBeat;
11132
11133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11134 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
11135 }
11136
11137 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
11138 where
11139 V: serde::de::MapAccess<'de>,
11140 {
11141 let mut progress__ = None;
11142 while let Some(k) = map_.next_key()? {
11143 match k {
11144 GeneratedField::Progress => {
11145 if progress__.is_some() {
11146 return Err(serde::de::Error::duplicate_field("progress"));
11147 }
11148 progress__ = Some(map_.next_value()?);
11149 }
11150 }
11151 }
11152 Ok(report_compaction_task_request::HeartBeat {
11153 progress: progress__.unwrap_or_default(),
11154 })
11155 }
11156 }
11157 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
11158 }
11159}
11160impl serde::Serialize for report_compaction_task_request::ReportTask {
11161 #[allow(deprecated)]
11162 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11163 where
11164 S: serde::Serializer,
11165 {
11166 use serde::ser::SerializeStruct;
11167 let mut len = 0;
11168 if self.compact_task.is_some() {
11169 len += 1;
11170 }
11171 if !self.table_stats_change.is_empty() {
11172 len += 1;
11173 }
11174 if !self.object_timestamps.is_empty() {
11175 len += 1;
11176 }
11177 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
11178 if let Some(v) = self.compact_task.as_ref() {
11179 struct_ser.serialize_field("compactTask", v)?;
11180 }
11181 if !self.table_stats_change.is_empty() {
11182 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
11183 }
11184 if !self.object_timestamps.is_empty() {
11185 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
11186 .map(|(k, v)| (k, v.to_string())).collect();
11187 struct_ser.serialize_field("objectTimestamps", &v)?;
11188 }
11189 struct_ser.end()
11190 }
11191}
11192impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
11193 #[allow(deprecated)]
11194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11195 where
11196 D: serde::Deserializer<'de>,
11197 {
11198 const FIELDS: &[&str] = &[
11199 "compact_task",
11200 "compactTask",
11201 "table_stats_change",
11202 "tableStatsChange",
11203 "object_timestamps",
11204 "objectTimestamps",
11205 ];
11206
11207 #[allow(clippy::enum_variant_names)]
11208 enum GeneratedField {
11209 CompactTask,
11210 TableStatsChange,
11211 ObjectTimestamps,
11212 }
11213 impl<'de> serde::Deserialize<'de> for GeneratedField {
11214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11215 where
11216 D: serde::Deserializer<'de>,
11217 {
11218 struct GeneratedVisitor;
11219
11220 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11221 type Value = GeneratedField;
11222
11223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11224 write!(formatter, "expected one of: {:?}", &FIELDS)
11225 }
11226
11227 #[allow(unused_variables)]
11228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11229 where
11230 E: serde::de::Error,
11231 {
11232 match value {
11233 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
11234 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
11235 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
11236 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11237 }
11238 }
11239 }
11240 deserializer.deserialize_identifier(GeneratedVisitor)
11241 }
11242 }
11243 struct GeneratedVisitor;
11244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11245 type Value = report_compaction_task_request::ReportTask;
11246
11247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11248 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
11249 }
11250
11251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
11252 where
11253 V: serde::de::MapAccess<'de>,
11254 {
11255 let mut compact_task__ = None;
11256 let mut table_stats_change__ = None;
11257 let mut object_timestamps__ = None;
11258 while let Some(k) = map_.next_key()? {
11259 match k {
11260 GeneratedField::CompactTask => {
11261 if compact_task__.is_some() {
11262 return Err(serde::de::Error::duplicate_field("compactTask"));
11263 }
11264 compact_task__ = map_.next_value()?;
11265 }
11266 GeneratedField::TableStatsChange => {
11267 if table_stats_change__.is_some() {
11268 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
11269 }
11270 table_stats_change__ = Some(
11271 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11272 .into_iter().map(|(k,v)| (k.0, v)).collect()
11273 );
11274 }
11275 GeneratedField::ObjectTimestamps => {
11276 if object_timestamps__.is_some() {
11277 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
11278 }
11279 object_timestamps__ = Some(
11280 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
11281 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
11282 );
11283 }
11284 }
11285 }
11286 Ok(report_compaction_task_request::ReportTask {
11287 compact_task: compact_task__,
11288 table_stats_change: table_stats_change__.unwrap_or_default(),
11289 object_timestamps: object_timestamps__.unwrap_or_default(),
11290 })
11291 }
11292 }
11293 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
11294 }
11295}
11296impl serde::Serialize for ReportCompactionTaskResponse {
11297 #[allow(deprecated)]
11298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11299 where
11300 S: serde::Serializer,
11301 {
11302 use serde::ser::SerializeStruct;
11303 let mut len = 0;
11304 if self.status.is_some() {
11305 len += 1;
11306 }
11307 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
11308 if let Some(v) = self.status.as_ref() {
11309 struct_ser.serialize_field("status", v)?;
11310 }
11311 struct_ser.end()
11312 }
11313}
11314impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
11315 #[allow(deprecated)]
11316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11317 where
11318 D: serde::Deserializer<'de>,
11319 {
11320 const FIELDS: &[&str] = &[
11321 "status",
11322 ];
11323
11324 #[allow(clippy::enum_variant_names)]
11325 enum GeneratedField {
11326 Status,
11327 }
11328 impl<'de> serde::Deserialize<'de> for GeneratedField {
11329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11330 where
11331 D: serde::Deserializer<'de>,
11332 {
11333 struct GeneratedVisitor;
11334
11335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11336 type Value = GeneratedField;
11337
11338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11339 write!(formatter, "expected one of: {:?}", &FIELDS)
11340 }
11341
11342 #[allow(unused_variables)]
11343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11344 where
11345 E: serde::de::Error,
11346 {
11347 match value {
11348 "status" => Ok(GeneratedField::Status),
11349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11350 }
11351 }
11352 }
11353 deserializer.deserialize_identifier(GeneratedVisitor)
11354 }
11355 }
11356 struct GeneratedVisitor;
11357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11358 type Value = ReportCompactionTaskResponse;
11359
11360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11361 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
11362 }
11363
11364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
11365 where
11366 V: serde::de::MapAccess<'de>,
11367 {
11368 let mut status__ = None;
11369 while let Some(k) = map_.next_key()? {
11370 match k {
11371 GeneratedField::Status => {
11372 if status__.is_some() {
11373 return Err(serde::de::Error::duplicate_field("status"));
11374 }
11375 status__ = map_.next_value()?;
11376 }
11377 }
11378 }
11379 Ok(ReportCompactionTaskResponse {
11380 status: status__,
11381 })
11382 }
11383 }
11384 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
11385 }
11386}
11387impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
11388 #[allow(deprecated)]
11389 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11390 where
11391 S: serde::Serializer,
11392 {
11393 use serde::ser::SerializeStruct;
11394 let len = 0;
11395 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
11396 struct_ser.end()
11397 }
11398}
11399impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
11400 #[allow(deprecated)]
11401 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11402 where
11403 D: serde::Deserializer<'de>,
11404 {
11405 const FIELDS: &[&str] = &[
11406 ];
11407
11408 #[allow(clippy::enum_variant_names)]
11409 enum GeneratedField {
11410 }
11411 impl<'de> serde::Deserialize<'de> for GeneratedField {
11412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11413 where
11414 D: serde::Deserializer<'de>,
11415 {
11416 struct GeneratedVisitor;
11417
11418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11419 type Value = GeneratedField;
11420
11421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11422 write!(formatter, "expected one of: {:?}", &FIELDS)
11423 }
11424
11425 #[allow(unused_variables)]
11426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11427 where
11428 E: serde::de::Error,
11429 {
11430 Err(serde::de::Error::unknown_field(value, FIELDS))
11431 }
11432 }
11433 deserializer.deserialize_identifier(GeneratedVisitor)
11434 }
11435 }
11436 struct GeneratedVisitor;
11437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11438 type Value = RiseCtlGetCheckpointVersionRequest;
11439
11440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11441 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
11442 }
11443
11444 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
11445 where
11446 V: serde::de::MapAccess<'de>,
11447 {
11448 while map_.next_key::<GeneratedField>()?.is_some() {
11449 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11450 }
11451 Ok(RiseCtlGetCheckpointVersionRequest {
11452 })
11453 }
11454 }
11455 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
11456 }
11457}
11458impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
11459 #[allow(deprecated)]
11460 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11461 where
11462 S: serde::Serializer,
11463 {
11464 use serde::ser::SerializeStruct;
11465 let mut len = 0;
11466 if self.checkpoint_version.is_some() {
11467 len += 1;
11468 }
11469 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
11470 if let Some(v) = self.checkpoint_version.as_ref() {
11471 struct_ser.serialize_field("checkpointVersion", v)?;
11472 }
11473 struct_ser.end()
11474 }
11475}
11476impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
11477 #[allow(deprecated)]
11478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11479 where
11480 D: serde::Deserializer<'de>,
11481 {
11482 const FIELDS: &[&str] = &[
11483 "checkpoint_version",
11484 "checkpointVersion",
11485 ];
11486
11487 #[allow(clippy::enum_variant_names)]
11488 enum GeneratedField {
11489 CheckpointVersion,
11490 }
11491 impl<'de> serde::Deserialize<'de> for GeneratedField {
11492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11493 where
11494 D: serde::Deserializer<'de>,
11495 {
11496 struct GeneratedVisitor;
11497
11498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11499 type Value = GeneratedField;
11500
11501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11502 write!(formatter, "expected one of: {:?}", &FIELDS)
11503 }
11504
11505 #[allow(unused_variables)]
11506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11507 where
11508 E: serde::de::Error,
11509 {
11510 match value {
11511 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
11512 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11513 }
11514 }
11515 }
11516 deserializer.deserialize_identifier(GeneratedVisitor)
11517 }
11518 }
11519 struct GeneratedVisitor;
11520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11521 type Value = RiseCtlGetCheckpointVersionResponse;
11522
11523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11524 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
11525 }
11526
11527 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
11528 where
11529 V: serde::de::MapAccess<'de>,
11530 {
11531 let mut checkpoint_version__ = None;
11532 while let Some(k) = map_.next_key()? {
11533 match k {
11534 GeneratedField::CheckpointVersion => {
11535 if checkpoint_version__.is_some() {
11536 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
11537 }
11538 checkpoint_version__ = map_.next_value()?;
11539 }
11540 }
11541 }
11542 Ok(RiseCtlGetCheckpointVersionResponse {
11543 checkpoint_version: checkpoint_version__,
11544 })
11545 }
11546 }
11547 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
11548 }
11549}
11550impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
11551 #[allow(deprecated)]
11552 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11553 where
11554 S: serde::Serializer,
11555 {
11556 use serde::ser::SerializeStruct;
11557 let len = 0;
11558 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
11559 struct_ser.end()
11560 }
11561}
11562impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
11563 #[allow(deprecated)]
11564 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11565 where
11566 D: serde::Deserializer<'de>,
11567 {
11568 const FIELDS: &[&str] = &[
11569 ];
11570
11571 #[allow(clippy::enum_variant_names)]
11572 enum GeneratedField {
11573 }
11574 impl<'de> serde::Deserialize<'de> for GeneratedField {
11575 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11576 where
11577 D: serde::Deserializer<'de>,
11578 {
11579 struct GeneratedVisitor;
11580
11581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11582 type Value = GeneratedField;
11583
11584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11585 write!(formatter, "expected one of: {:?}", &FIELDS)
11586 }
11587
11588 #[allow(unused_variables)]
11589 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11590 where
11591 E: serde::de::Error,
11592 {
11593 Err(serde::de::Error::unknown_field(value, FIELDS))
11594 }
11595 }
11596 deserializer.deserialize_identifier(GeneratedVisitor)
11597 }
11598 }
11599 struct GeneratedVisitor;
11600 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11601 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
11602
11603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11604 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
11605 }
11606
11607 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
11608 where
11609 V: serde::de::MapAccess<'de>,
11610 {
11611 while map_.next_key::<GeneratedField>()?.is_some() {
11612 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11613 }
11614 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
11615 })
11616 }
11617 }
11618 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
11619 }
11620}
11621impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
11622 #[allow(deprecated)]
11623 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11624 where
11625 S: serde::Serializer,
11626 {
11627 use serde::ser::SerializeStruct;
11628 let mut len = 0;
11629 if self.summary.is_some() {
11630 len += 1;
11631 }
11632 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
11633 if let Some(v) = self.summary.as_ref() {
11634 struct_ser.serialize_field("summary", v)?;
11635 }
11636 struct_ser.end()
11637 }
11638}
11639impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
11640 #[allow(deprecated)]
11641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11642 where
11643 D: serde::Deserializer<'de>,
11644 {
11645 const FIELDS: &[&str] = &[
11646 "summary",
11647 ];
11648
11649 #[allow(clippy::enum_variant_names)]
11650 enum GeneratedField {
11651 Summary,
11652 }
11653 impl<'de> serde::Deserialize<'de> for GeneratedField {
11654 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11655 where
11656 D: serde::Deserializer<'de>,
11657 {
11658 struct GeneratedVisitor;
11659
11660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11661 type Value = GeneratedField;
11662
11663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11664 write!(formatter, "expected one of: {:?}", &FIELDS)
11665 }
11666
11667 #[allow(unused_variables)]
11668 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11669 where
11670 E: serde::de::Error,
11671 {
11672 match value {
11673 "summary" => Ok(GeneratedField::Summary),
11674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11675 }
11676 }
11677 }
11678 deserializer.deserialize_identifier(GeneratedVisitor)
11679 }
11680 }
11681 struct GeneratedVisitor;
11682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11683 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
11684
11685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11686 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
11687 }
11688
11689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
11690 where
11691 V: serde::de::MapAccess<'de>,
11692 {
11693 let mut summary__ = None;
11694 while let Some(k) = map_.next_key()? {
11695 match k {
11696 GeneratedField::Summary => {
11697 if summary__.is_some() {
11698 return Err(serde::de::Error::duplicate_field("summary"));
11699 }
11700 summary__ = map_.next_value()?;
11701 }
11702 }
11703 }
11704 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
11705 summary: summary__,
11706 })
11707 }
11708 }
11709 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
11710 }
11711}
11712impl serde::Serialize for RiseCtlListCompactionGroupRequest {
11713 #[allow(deprecated)]
11714 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11715 where
11716 S: serde::Serializer,
11717 {
11718 use serde::ser::SerializeStruct;
11719 let len = 0;
11720 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
11721 struct_ser.end()
11722 }
11723}
11724impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
11725 #[allow(deprecated)]
11726 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11727 where
11728 D: serde::Deserializer<'de>,
11729 {
11730 const FIELDS: &[&str] = &[
11731 ];
11732
11733 #[allow(clippy::enum_variant_names)]
11734 enum GeneratedField {
11735 }
11736 impl<'de> serde::Deserialize<'de> for GeneratedField {
11737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11738 where
11739 D: serde::Deserializer<'de>,
11740 {
11741 struct GeneratedVisitor;
11742
11743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11744 type Value = GeneratedField;
11745
11746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11747 write!(formatter, "expected one of: {:?}", &FIELDS)
11748 }
11749
11750 #[allow(unused_variables)]
11751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11752 where
11753 E: serde::de::Error,
11754 {
11755 Err(serde::de::Error::unknown_field(value, FIELDS))
11756 }
11757 }
11758 deserializer.deserialize_identifier(GeneratedVisitor)
11759 }
11760 }
11761 struct GeneratedVisitor;
11762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11763 type Value = RiseCtlListCompactionGroupRequest;
11764
11765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11766 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
11767 }
11768
11769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
11770 where
11771 V: serde::de::MapAccess<'de>,
11772 {
11773 while map_.next_key::<GeneratedField>()?.is_some() {
11774 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11775 }
11776 Ok(RiseCtlListCompactionGroupRequest {
11777 })
11778 }
11779 }
11780 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
11781 }
11782}
11783impl serde::Serialize for RiseCtlListCompactionGroupResponse {
11784 #[allow(deprecated)]
11785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11786 where
11787 S: serde::Serializer,
11788 {
11789 use serde::ser::SerializeStruct;
11790 let mut len = 0;
11791 if self.status.is_some() {
11792 len += 1;
11793 }
11794 if !self.compaction_groups.is_empty() {
11795 len += 1;
11796 }
11797 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
11798 if let Some(v) = self.status.as_ref() {
11799 struct_ser.serialize_field("status", v)?;
11800 }
11801 if !self.compaction_groups.is_empty() {
11802 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
11803 }
11804 struct_ser.end()
11805 }
11806}
11807impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
11808 #[allow(deprecated)]
11809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11810 where
11811 D: serde::Deserializer<'de>,
11812 {
11813 const FIELDS: &[&str] = &[
11814 "status",
11815 "compaction_groups",
11816 "compactionGroups",
11817 ];
11818
11819 #[allow(clippy::enum_variant_names)]
11820 enum GeneratedField {
11821 Status,
11822 CompactionGroups,
11823 }
11824 impl<'de> serde::Deserialize<'de> for GeneratedField {
11825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11826 where
11827 D: serde::Deserializer<'de>,
11828 {
11829 struct GeneratedVisitor;
11830
11831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11832 type Value = GeneratedField;
11833
11834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11835 write!(formatter, "expected one of: {:?}", &FIELDS)
11836 }
11837
11838 #[allow(unused_variables)]
11839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11840 where
11841 E: serde::de::Error,
11842 {
11843 match value {
11844 "status" => Ok(GeneratedField::Status),
11845 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
11846 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11847 }
11848 }
11849 }
11850 deserializer.deserialize_identifier(GeneratedVisitor)
11851 }
11852 }
11853 struct GeneratedVisitor;
11854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11855 type Value = RiseCtlListCompactionGroupResponse;
11856
11857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11858 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
11859 }
11860
11861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
11862 where
11863 V: serde::de::MapAccess<'de>,
11864 {
11865 let mut status__ = None;
11866 let mut compaction_groups__ = None;
11867 while let Some(k) = map_.next_key()? {
11868 match k {
11869 GeneratedField::Status => {
11870 if status__.is_some() {
11871 return Err(serde::de::Error::duplicate_field("status"));
11872 }
11873 status__ = map_.next_value()?;
11874 }
11875 GeneratedField::CompactionGroups => {
11876 if compaction_groups__.is_some() {
11877 return Err(serde::de::Error::duplicate_field("compactionGroups"));
11878 }
11879 compaction_groups__ = Some(map_.next_value()?);
11880 }
11881 }
11882 }
11883 Ok(RiseCtlListCompactionGroupResponse {
11884 status: status__,
11885 compaction_groups: compaction_groups__.unwrap_or_default(),
11886 })
11887 }
11888 }
11889 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
11890 }
11891}
11892impl serde::Serialize for RiseCtlListCompactionStatusRequest {
11893 #[allow(deprecated)]
11894 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11895 where
11896 S: serde::Serializer,
11897 {
11898 use serde::ser::SerializeStruct;
11899 let len = 0;
11900 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
11901 struct_ser.end()
11902 }
11903}
11904impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
11905 #[allow(deprecated)]
11906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11907 where
11908 D: serde::Deserializer<'de>,
11909 {
11910 const FIELDS: &[&str] = &[
11911 ];
11912
11913 #[allow(clippy::enum_variant_names)]
11914 enum GeneratedField {
11915 }
11916 impl<'de> serde::Deserialize<'de> for GeneratedField {
11917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11918 where
11919 D: serde::Deserializer<'de>,
11920 {
11921 struct GeneratedVisitor;
11922
11923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11924 type Value = GeneratedField;
11925
11926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11927 write!(formatter, "expected one of: {:?}", &FIELDS)
11928 }
11929
11930 #[allow(unused_variables)]
11931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11932 where
11933 E: serde::de::Error,
11934 {
11935 Err(serde::de::Error::unknown_field(value, FIELDS))
11936 }
11937 }
11938 deserializer.deserialize_identifier(GeneratedVisitor)
11939 }
11940 }
11941 struct GeneratedVisitor;
11942 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11943 type Value = RiseCtlListCompactionStatusRequest;
11944
11945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11946 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
11947 }
11948
11949 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
11950 where
11951 V: serde::de::MapAccess<'de>,
11952 {
11953 while map_.next_key::<GeneratedField>()?.is_some() {
11954 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11955 }
11956 Ok(RiseCtlListCompactionStatusRequest {
11957 })
11958 }
11959 }
11960 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
11961 }
11962}
11963impl serde::Serialize for RiseCtlListCompactionStatusResponse {
11964 #[allow(deprecated)]
11965 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11966 where
11967 S: serde::Serializer,
11968 {
11969 use serde::ser::SerializeStruct;
11970 let mut len = 0;
11971 if !self.compaction_statuses.is_empty() {
11972 len += 1;
11973 }
11974 if !self.task_assignment.is_empty() {
11975 len += 1;
11976 }
11977 if !self.task_progress.is_empty() {
11978 len += 1;
11979 }
11980 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
11981 if !self.compaction_statuses.is_empty() {
11982 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
11983 }
11984 if !self.task_assignment.is_empty() {
11985 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
11986 }
11987 if !self.task_progress.is_empty() {
11988 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
11989 }
11990 struct_ser.end()
11991 }
11992}
11993impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
11994 #[allow(deprecated)]
11995 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11996 where
11997 D: serde::Deserializer<'de>,
11998 {
11999 const FIELDS: &[&str] = &[
12000 "compaction_statuses",
12001 "compactionStatuses",
12002 "task_assignment",
12003 "taskAssignment",
12004 "task_progress",
12005 "taskProgress",
12006 ];
12007
12008 #[allow(clippy::enum_variant_names)]
12009 enum GeneratedField {
12010 CompactionStatuses,
12011 TaskAssignment,
12012 TaskProgress,
12013 }
12014 impl<'de> serde::Deserialize<'de> for GeneratedField {
12015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12016 where
12017 D: serde::Deserializer<'de>,
12018 {
12019 struct GeneratedVisitor;
12020
12021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12022 type Value = GeneratedField;
12023
12024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12025 write!(formatter, "expected one of: {:?}", &FIELDS)
12026 }
12027
12028 #[allow(unused_variables)]
12029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12030 where
12031 E: serde::de::Error,
12032 {
12033 match value {
12034 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
12035 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
12036 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
12037 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12038 }
12039 }
12040 }
12041 deserializer.deserialize_identifier(GeneratedVisitor)
12042 }
12043 }
12044 struct GeneratedVisitor;
12045 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12046 type Value = RiseCtlListCompactionStatusResponse;
12047
12048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12049 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
12050 }
12051
12052 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
12053 where
12054 V: serde::de::MapAccess<'de>,
12055 {
12056 let mut compaction_statuses__ = None;
12057 let mut task_assignment__ = None;
12058 let mut task_progress__ = None;
12059 while let Some(k) = map_.next_key()? {
12060 match k {
12061 GeneratedField::CompactionStatuses => {
12062 if compaction_statuses__.is_some() {
12063 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
12064 }
12065 compaction_statuses__ = Some(map_.next_value()?);
12066 }
12067 GeneratedField::TaskAssignment => {
12068 if task_assignment__.is_some() {
12069 return Err(serde::de::Error::duplicate_field("taskAssignment"));
12070 }
12071 task_assignment__ = Some(map_.next_value()?);
12072 }
12073 GeneratedField::TaskProgress => {
12074 if task_progress__.is_some() {
12075 return Err(serde::de::Error::duplicate_field("taskProgress"));
12076 }
12077 task_progress__ = Some(map_.next_value()?);
12078 }
12079 }
12080 }
12081 Ok(RiseCtlListCompactionStatusResponse {
12082 compaction_statuses: compaction_statuses__.unwrap_or_default(),
12083 task_assignment: task_assignment__.unwrap_or_default(),
12084 task_progress: task_progress__.unwrap_or_default(),
12085 })
12086 }
12087 }
12088 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
12089 }
12090}
12091impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
12092 #[allow(deprecated)]
12093 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12094 where
12095 S: serde::Serializer,
12096 {
12097 use serde::ser::SerializeStruct;
12098 let len = 0;
12099 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
12100 struct_ser.end()
12101 }
12102}
12103impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
12104 #[allow(deprecated)]
12105 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12106 where
12107 D: serde::Deserializer<'de>,
12108 {
12109 const FIELDS: &[&str] = &[
12110 ];
12111
12112 #[allow(clippy::enum_variant_names)]
12113 enum GeneratedField {
12114 }
12115 impl<'de> serde::Deserialize<'de> for GeneratedField {
12116 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12117 where
12118 D: serde::Deserializer<'de>,
12119 {
12120 struct GeneratedVisitor;
12121
12122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12123 type Value = GeneratedField;
12124
12125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12126 write!(formatter, "expected one of: {:?}", &FIELDS)
12127 }
12128
12129 #[allow(unused_variables)]
12130 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12131 where
12132 E: serde::de::Error,
12133 {
12134 Err(serde::de::Error::unknown_field(value, FIELDS))
12135 }
12136 }
12137 deserializer.deserialize_identifier(GeneratedVisitor)
12138 }
12139 }
12140 struct GeneratedVisitor;
12141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12142 type Value = RiseCtlPauseVersionCheckpointRequest;
12143
12144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12145 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
12146 }
12147
12148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
12149 where
12150 V: serde::de::MapAccess<'de>,
12151 {
12152 while map_.next_key::<GeneratedField>()?.is_some() {
12153 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12154 }
12155 Ok(RiseCtlPauseVersionCheckpointRequest {
12156 })
12157 }
12158 }
12159 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12160 }
12161}
12162impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
12163 #[allow(deprecated)]
12164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12165 where
12166 S: serde::Serializer,
12167 {
12168 use serde::ser::SerializeStruct;
12169 let len = 0;
12170 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
12171 struct_ser.end()
12172 }
12173}
12174impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
12175 #[allow(deprecated)]
12176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12177 where
12178 D: serde::Deserializer<'de>,
12179 {
12180 const FIELDS: &[&str] = &[
12181 ];
12182
12183 #[allow(clippy::enum_variant_names)]
12184 enum GeneratedField {
12185 }
12186 impl<'de> serde::Deserialize<'de> for GeneratedField {
12187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12188 where
12189 D: serde::Deserializer<'de>,
12190 {
12191 struct GeneratedVisitor;
12192
12193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12194 type Value = GeneratedField;
12195
12196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12197 write!(formatter, "expected one of: {:?}", &FIELDS)
12198 }
12199
12200 #[allow(unused_variables)]
12201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12202 where
12203 E: serde::de::Error,
12204 {
12205 Err(serde::de::Error::unknown_field(value, FIELDS))
12206 }
12207 }
12208 deserializer.deserialize_identifier(GeneratedVisitor)
12209 }
12210 }
12211 struct GeneratedVisitor;
12212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12213 type Value = RiseCtlPauseVersionCheckpointResponse;
12214
12215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12216 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
12217 }
12218
12219 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
12220 where
12221 V: serde::de::MapAccess<'de>,
12222 {
12223 while map_.next_key::<GeneratedField>()?.is_some() {
12224 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12225 }
12226 Ok(RiseCtlPauseVersionCheckpointResponse {
12227 })
12228 }
12229 }
12230 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
12231 }
12232}
12233impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
12234 #[allow(deprecated)]
12235 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12236 where
12237 S: serde::Serializer,
12238 {
12239 use serde::ser::SerializeStruct;
12240 let len = 0;
12241 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
12242 struct_ser.end()
12243 }
12244}
12245impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
12246 #[allow(deprecated)]
12247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12248 where
12249 D: serde::Deserializer<'de>,
12250 {
12251 const FIELDS: &[&str] = &[
12252 ];
12253
12254 #[allow(clippy::enum_variant_names)]
12255 enum GeneratedField {
12256 }
12257 impl<'de> serde::Deserialize<'de> for GeneratedField {
12258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12259 where
12260 D: serde::Deserializer<'de>,
12261 {
12262 struct GeneratedVisitor;
12263
12264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12265 type Value = GeneratedField;
12266
12267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12268 write!(formatter, "expected one of: {:?}", &FIELDS)
12269 }
12270
12271 #[allow(unused_variables)]
12272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12273 where
12274 E: serde::de::Error,
12275 {
12276 Err(serde::de::Error::unknown_field(value, FIELDS))
12277 }
12278 }
12279 deserializer.deserialize_identifier(GeneratedVisitor)
12280 }
12281 }
12282 struct GeneratedVisitor;
12283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12284 type Value = RiseCtlRebuildTableStatsRequest;
12285
12286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12287 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
12288 }
12289
12290 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
12291 where
12292 V: serde::de::MapAccess<'de>,
12293 {
12294 while map_.next_key::<GeneratedField>()?.is_some() {
12295 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12296 }
12297 Ok(RiseCtlRebuildTableStatsRequest {
12298 })
12299 }
12300 }
12301 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
12302 }
12303}
12304impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
12305 #[allow(deprecated)]
12306 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12307 where
12308 S: serde::Serializer,
12309 {
12310 use serde::ser::SerializeStruct;
12311 let len = 0;
12312 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
12313 struct_ser.end()
12314 }
12315}
12316impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
12317 #[allow(deprecated)]
12318 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12319 where
12320 D: serde::Deserializer<'de>,
12321 {
12322 const FIELDS: &[&str] = &[
12323 ];
12324
12325 #[allow(clippy::enum_variant_names)]
12326 enum GeneratedField {
12327 }
12328 impl<'de> serde::Deserialize<'de> for GeneratedField {
12329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12330 where
12331 D: serde::Deserializer<'de>,
12332 {
12333 struct GeneratedVisitor;
12334
12335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12336 type Value = GeneratedField;
12337
12338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12339 write!(formatter, "expected one of: {:?}", &FIELDS)
12340 }
12341
12342 #[allow(unused_variables)]
12343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12344 where
12345 E: serde::de::Error,
12346 {
12347 Err(serde::de::Error::unknown_field(value, FIELDS))
12348 }
12349 }
12350 deserializer.deserialize_identifier(GeneratedVisitor)
12351 }
12352 }
12353 struct GeneratedVisitor;
12354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12355 type Value = RiseCtlRebuildTableStatsResponse;
12356
12357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12358 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
12359 }
12360
12361 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
12362 where
12363 V: serde::de::MapAccess<'de>,
12364 {
12365 while map_.next_key::<GeneratedField>()?.is_some() {
12366 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12367 }
12368 Ok(RiseCtlRebuildTableStatsResponse {
12369 })
12370 }
12371 }
12372 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
12373 }
12374}
12375impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
12376 #[allow(deprecated)]
12377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12378 where
12379 S: serde::Serializer,
12380 {
12381 use serde::ser::SerializeStruct;
12382 let len = 0;
12383 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
12384 struct_ser.end()
12385 }
12386}
12387impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
12388 #[allow(deprecated)]
12389 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12390 where
12391 D: serde::Deserializer<'de>,
12392 {
12393 const FIELDS: &[&str] = &[
12394 ];
12395
12396 #[allow(clippy::enum_variant_names)]
12397 enum GeneratedField {
12398 }
12399 impl<'de> serde::Deserialize<'de> for GeneratedField {
12400 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12401 where
12402 D: serde::Deserializer<'de>,
12403 {
12404 struct GeneratedVisitor;
12405
12406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12407 type Value = GeneratedField;
12408
12409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12410 write!(formatter, "expected one of: {:?}", &FIELDS)
12411 }
12412
12413 #[allow(unused_variables)]
12414 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12415 where
12416 E: serde::de::Error,
12417 {
12418 Err(serde::de::Error::unknown_field(value, FIELDS))
12419 }
12420 }
12421 deserializer.deserialize_identifier(GeneratedVisitor)
12422 }
12423 }
12424 struct GeneratedVisitor;
12425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12426 type Value = RiseCtlResumeVersionCheckpointRequest;
12427
12428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12429 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
12430 }
12431
12432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
12433 where
12434 V: serde::de::MapAccess<'de>,
12435 {
12436 while map_.next_key::<GeneratedField>()?.is_some() {
12437 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12438 }
12439 Ok(RiseCtlResumeVersionCheckpointRequest {
12440 })
12441 }
12442 }
12443 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12444 }
12445}
12446impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
12447 #[allow(deprecated)]
12448 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12449 where
12450 S: serde::Serializer,
12451 {
12452 use serde::ser::SerializeStruct;
12453 let len = 0;
12454 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
12455 struct_ser.end()
12456 }
12457}
12458impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
12459 #[allow(deprecated)]
12460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12461 where
12462 D: serde::Deserializer<'de>,
12463 {
12464 const FIELDS: &[&str] = &[
12465 ];
12466
12467 #[allow(clippy::enum_variant_names)]
12468 enum GeneratedField {
12469 }
12470 impl<'de> serde::Deserialize<'de> for GeneratedField {
12471 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12472 where
12473 D: serde::Deserializer<'de>,
12474 {
12475 struct GeneratedVisitor;
12476
12477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12478 type Value = GeneratedField;
12479
12480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12481 write!(formatter, "expected one of: {:?}", &FIELDS)
12482 }
12483
12484 #[allow(unused_variables)]
12485 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12486 where
12487 E: serde::de::Error,
12488 {
12489 Err(serde::de::Error::unknown_field(value, FIELDS))
12490 }
12491 }
12492 deserializer.deserialize_identifier(GeneratedVisitor)
12493 }
12494 }
12495 struct GeneratedVisitor;
12496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12497 type Value = RiseCtlResumeVersionCheckpointResponse;
12498
12499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12500 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
12501 }
12502
12503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
12504 where
12505 V: serde::de::MapAccess<'de>,
12506 {
12507 while map_.next_key::<GeneratedField>()?.is_some() {
12508 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12509 }
12510 Ok(RiseCtlResumeVersionCheckpointResponse {
12511 })
12512 }
12513 }
12514 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
12515 }
12516}
12517impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
12518 #[allow(deprecated)]
12519 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12520 where
12521 S: serde::Serializer,
12522 {
12523 use serde::ser::SerializeStruct;
12524 let mut len = 0;
12525 if !self.compaction_group_ids.is_empty() {
12526 len += 1;
12527 }
12528 if !self.configs.is_empty() {
12529 len += 1;
12530 }
12531 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
12532 if !self.compaction_group_ids.is_empty() {
12533 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
12534 }
12535 if !self.configs.is_empty() {
12536 struct_ser.serialize_field("configs", &self.configs)?;
12537 }
12538 struct_ser.end()
12539 }
12540}
12541impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
12542 #[allow(deprecated)]
12543 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12544 where
12545 D: serde::Deserializer<'de>,
12546 {
12547 const FIELDS: &[&str] = &[
12548 "compaction_group_ids",
12549 "compactionGroupIds",
12550 "configs",
12551 ];
12552
12553 #[allow(clippy::enum_variant_names)]
12554 enum GeneratedField {
12555 CompactionGroupIds,
12556 Configs,
12557 }
12558 impl<'de> serde::Deserialize<'de> for GeneratedField {
12559 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12560 where
12561 D: serde::Deserializer<'de>,
12562 {
12563 struct GeneratedVisitor;
12564
12565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12566 type Value = GeneratedField;
12567
12568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12569 write!(formatter, "expected one of: {:?}", &FIELDS)
12570 }
12571
12572 #[allow(unused_variables)]
12573 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12574 where
12575 E: serde::de::Error,
12576 {
12577 match value {
12578 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
12579 "configs" => Ok(GeneratedField::Configs),
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 = RiseCtlUpdateCompactionConfigRequest;
12590
12591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12592 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
12593 }
12594
12595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
12596 where
12597 V: serde::de::MapAccess<'de>,
12598 {
12599 let mut compaction_group_ids__ = None;
12600 let mut configs__ = None;
12601 while let Some(k) = map_.next_key()? {
12602 match k {
12603 GeneratedField::CompactionGroupIds => {
12604 if compaction_group_ids__.is_some() {
12605 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
12606 }
12607 compaction_group_ids__ =
12608 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12609 .into_iter().map(|x| x.0).collect())
12610 ;
12611 }
12612 GeneratedField::Configs => {
12613 if configs__.is_some() {
12614 return Err(serde::de::Error::duplicate_field("configs"));
12615 }
12616 configs__ = Some(map_.next_value()?);
12617 }
12618 }
12619 }
12620 Ok(RiseCtlUpdateCompactionConfigRequest {
12621 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
12622 configs: configs__.unwrap_or_default(),
12623 })
12624 }
12625 }
12626 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
12627 }
12628}
12629impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12630 #[allow(deprecated)]
12631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12632 where
12633 S: serde::Serializer,
12634 {
12635 use serde::ser::SerializeStruct;
12636 let mut len = 0;
12637 if self.level != 0 {
12638 len += 1;
12639 }
12640 if !self.compression_algorithm.is_empty() {
12641 len += 1;
12642 }
12643 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
12644 if self.level != 0 {
12645 struct_ser.serialize_field("level", &self.level)?;
12646 }
12647 if !self.compression_algorithm.is_empty() {
12648 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
12649 }
12650 struct_ser.end()
12651 }
12652}
12653impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12654 #[allow(deprecated)]
12655 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12656 where
12657 D: serde::Deserializer<'de>,
12658 {
12659 const FIELDS: &[&str] = &[
12660 "level",
12661 "compression_algorithm",
12662 "compressionAlgorithm",
12663 ];
12664
12665 #[allow(clippy::enum_variant_names)]
12666 enum GeneratedField {
12667 Level,
12668 CompressionAlgorithm,
12669 }
12670 impl<'de> serde::Deserialize<'de> for GeneratedField {
12671 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12672 where
12673 D: serde::Deserializer<'de>,
12674 {
12675 struct GeneratedVisitor;
12676
12677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12678 type Value = GeneratedField;
12679
12680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12681 write!(formatter, "expected one of: {:?}", &FIELDS)
12682 }
12683
12684 #[allow(unused_variables)]
12685 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12686 where
12687 E: serde::de::Error,
12688 {
12689 match value {
12690 "level" => Ok(GeneratedField::Level),
12691 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12692 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12693 }
12694 }
12695 }
12696 deserializer.deserialize_identifier(GeneratedVisitor)
12697 }
12698 }
12699 struct GeneratedVisitor;
12700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12701 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
12702
12703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12704 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
12705 }
12706
12707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
12708 where
12709 V: serde::de::MapAccess<'de>,
12710 {
12711 let mut level__ = None;
12712 let mut compression_algorithm__ = None;
12713 while let Some(k) = map_.next_key()? {
12714 match k {
12715 GeneratedField::Level => {
12716 if level__.is_some() {
12717 return Err(serde::de::Error::duplicate_field("level"));
12718 }
12719 level__ =
12720 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12721 ;
12722 }
12723 GeneratedField::CompressionAlgorithm => {
12724 if compression_algorithm__.is_some() {
12725 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12726 }
12727 compression_algorithm__ = Some(map_.next_value()?);
12728 }
12729 }
12730 }
12731 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12732 level: level__.unwrap_or_default(),
12733 compression_algorithm: compression_algorithm__.unwrap_or_default(),
12734 })
12735 }
12736 }
12737 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
12738 }
12739}
12740impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
12741 #[allow(deprecated)]
12742 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12743 where
12744 S: serde::Serializer,
12745 {
12746 use serde::ser::SerializeStruct;
12747 let mut len = 0;
12748 if self.mutable_config.is_some() {
12749 len += 1;
12750 }
12751 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
12752 if let Some(v) = self.mutable_config.as_ref() {
12753 match v {
12754 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
12755 #[allow(clippy::needless_borrow)]
12756 #[allow(clippy::needless_borrows_for_generic_args)]
12757 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
12758 }
12759 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
12760 #[allow(clippy::needless_borrow)]
12761 #[allow(clippy::needless_borrows_for_generic_args)]
12762 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
12763 }
12764 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
12765 #[allow(clippy::needless_borrow)]
12766 #[allow(clippy::needless_borrows_for_generic_args)]
12767 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
12768 }
12769 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
12770 #[allow(clippy::needless_borrow)]
12771 #[allow(clippy::needless_borrows_for_generic_args)]
12772 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
12773 }
12774 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
12775 #[allow(clippy::needless_borrow)]
12776 #[allow(clippy::needless_borrows_for_generic_args)]
12777 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
12778 }
12779 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
12780 #[allow(clippy::needless_borrow)]
12781 #[allow(clippy::needless_borrows_for_generic_args)]
12782 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
12783 }
12784 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
12785 struct_ser.serialize_field("compactionFilterMask", v)?;
12786 }
12787 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
12788 struct_ser.serialize_field("maxSubCompaction", v)?;
12789 }
12790 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
12791 #[allow(clippy::needless_borrow)]
12792 #[allow(clippy::needless_borrows_for_generic_args)]
12793 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
12794 }
12795 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
12796 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
12797 }
12798 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
12799 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
12800 }
12801 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
12802 #[allow(clippy::needless_borrow)]
12803 #[allow(clippy::needless_borrows_for_generic_args)]
12804 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
12805 }
12806 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
12807 #[allow(clippy::needless_borrow)]
12808 #[allow(clippy::needless_borrows_for_generic_args)]
12809 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
12810 }
12811 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
12812 struct_ser.serialize_field("enableEmergencyPicker", v)?;
12813 }
12814 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
12815 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
12816 }
12817 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
12818 struct_ser.serialize_field("compressionAlgorithm", v)?;
12819 }
12820 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
12821 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
12822 }
12823 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
12824 #[allow(clippy::needless_borrow)]
12825 #[allow(clippy::needless_borrows_for_generic_args)]
12826 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
12827 }
12828 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
12829 struct_ser.serialize_field("splitWeightByVnode", v)?;
12830 }
12831 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
12832 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
12833 }
12834 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
12835 #[allow(clippy::needless_borrow)]
12836 #[allow(clippy::needless_borrows_for_generic_args)]
12837 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
12838 }
12839 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
12840 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
12841 }
12842 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
12843 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
12844 }
12845 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
12846 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
12847 }
12848 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
12849 #[allow(clippy::needless_borrow)]
12850 #[allow(clippy::needless_borrows_for_generic_args)]
12851 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
12852 }
12853 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
12854 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
12855 }
12856 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
12857 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
12858 }
12859 }
12860 }
12861 struct_ser.end()
12862 }
12863}
12864impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
12865 #[allow(deprecated)]
12866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12867 where
12868 D: serde::Deserializer<'de>,
12869 {
12870 const FIELDS: &[&str] = &[
12871 "max_bytes_for_level_base",
12872 "maxBytesForLevelBase",
12873 "max_bytes_for_level_multiplier",
12874 "maxBytesForLevelMultiplier",
12875 "max_compaction_bytes",
12876 "maxCompactionBytes",
12877 "sub_level_max_compaction_bytes",
12878 "subLevelMaxCompactionBytes",
12879 "level0_tier_compact_file_number",
12880 "level0TierCompactFileNumber",
12881 "target_file_size_base",
12882 "targetFileSizeBase",
12883 "compaction_filter_mask",
12884 "compactionFilterMask",
12885 "max_sub_compaction",
12886 "maxSubCompaction",
12887 "level0_stop_write_threshold_sub_level_number",
12888 "level0StopWriteThresholdSubLevelNumber",
12889 "level0_sub_level_compact_level_count",
12890 "level0SubLevelCompactLevelCount",
12891 "level0_overlapping_sub_level_compact_level_count",
12892 "level0OverlappingSubLevelCompactLevelCount",
12893 "max_space_reclaim_bytes",
12894 "maxSpaceReclaimBytes",
12895 "level0_max_compact_file_number",
12896 "level0MaxCompactFileNumber",
12897 "enable_emergency_picker",
12898 "enableEmergencyPicker",
12899 "tombstone_reclaim_ratio",
12900 "tombstoneReclaimRatio",
12901 "compression_algorithm",
12902 "compressionAlgorithm",
12903 "max_l0_compact_level_count",
12904 "maxL0CompactLevelCount",
12905 "sst_allowed_trivial_move_min_size",
12906 "sstAllowedTrivialMoveMinSize",
12907 "split_weight_by_vnode",
12908 "splitWeightByVnode",
12909 "disable_auto_group_scheduling",
12910 "disableAutoGroupScheduling",
12911 "max_overlapping_level_size",
12912 "maxOverlappingLevelSize",
12913 "emergency_level0_sst_file_count",
12914 "emergencyLevel0SstFileCount",
12915 "emergency_level0_sub_level_partition",
12916 "emergencyLevel0SubLevelPartition",
12917 "level0_stop_write_threshold_max_sst_count",
12918 "level0StopWriteThresholdMaxSstCount",
12919 "level0_stop_write_threshold_max_size",
12920 "level0StopWriteThresholdMaxSize",
12921 "sst_allowed_trivial_move_max_count",
12922 "sstAllowedTrivialMoveMaxCount",
12923 "enable_optimize_l0_interval_selection",
12924 "enableOptimizeL0IntervalSelection",
12925 ];
12926
12927 #[allow(clippy::enum_variant_names)]
12928 enum GeneratedField {
12929 MaxBytesForLevelBase,
12930 MaxBytesForLevelMultiplier,
12931 MaxCompactionBytes,
12932 SubLevelMaxCompactionBytes,
12933 Level0TierCompactFileNumber,
12934 TargetFileSizeBase,
12935 CompactionFilterMask,
12936 MaxSubCompaction,
12937 Level0StopWriteThresholdSubLevelNumber,
12938 Level0SubLevelCompactLevelCount,
12939 Level0OverlappingSubLevelCompactLevelCount,
12940 MaxSpaceReclaimBytes,
12941 Level0MaxCompactFileNumber,
12942 EnableEmergencyPicker,
12943 TombstoneReclaimRatio,
12944 CompressionAlgorithm,
12945 MaxL0CompactLevelCount,
12946 SstAllowedTrivialMoveMinSize,
12947 SplitWeightByVnode,
12948 DisableAutoGroupScheduling,
12949 MaxOverlappingLevelSize,
12950 EmergencyLevel0SstFileCount,
12951 EmergencyLevel0SubLevelPartition,
12952 Level0StopWriteThresholdMaxSstCount,
12953 Level0StopWriteThresholdMaxSize,
12954 SstAllowedTrivialMoveMaxCount,
12955 EnableOptimizeL0IntervalSelection,
12956 }
12957 impl<'de> serde::Deserialize<'de> for GeneratedField {
12958 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12959 where
12960 D: serde::Deserializer<'de>,
12961 {
12962 struct GeneratedVisitor;
12963
12964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12965 type Value = GeneratedField;
12966
12967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12968 write!(formatter, "expected one of: {:?}", &FIELDS)
12969 }
12970
12971 #[allow(unused_variables)]
12972 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12973 where
12974 E: serde::de::Error,
12975 {
12976 match value {
12977 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
12978 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
12979 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
12980 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
12981 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
12982 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
12983 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
12984 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
12985 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
12986 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
12987 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
12988 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
12989 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
12990 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
12991 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
12992 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12993 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
12994 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
12995 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
12996 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
12997 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
12998 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
12999 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
13000 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
13001 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
13002 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
13003 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
13004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13005 }
13006 }
13007 }
13008 deserializer.deserialize_identifier(GeneratedVisitor)
13009 }
13010 }
13011 struct GeneratedVisitor;
13012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13013 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
13014
13015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13016 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
13017 }
13018
13019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
13020 where
13021 V: serde::de::MapAccess<'de>,
13022 {
13023 let mut mutable_config__ = None;
13024 while let Some(k) = map_.next_key()? {
13025 match k {
13026 GeneratedField::MaxBytesForLevelBase => {
13027 if mutable_config__.is_some() {
13028 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
13029 }
13030 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));
13031 }
13032 GeneratedField::MaxBytesForLevelMultiplier => {
13033 if mutable_config__.is_some() {
13034 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
13035 }
13036 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));
13037 }
13038 GeneratedField::MaxCompactionBytes => {
13039 if mutable_config__.is_some() {
13040 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
13041 }
13042 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));
13043 }
13044 GeneratedField::SubLevelMaxCompactionBytes => {
13045 if mutable_config__.is_some() {
13046 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
13047 }
13048 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));
13049 }
13050 GeneratedField::Level0TierCompactFileNumber => {
13051 if mutable_config__.is_some() {
13052 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
13053 }
13054 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));
13055 }
13056 GeneratedField::TargetFileSizeBase => {
13057 if mutable_config__.is_some() {
13058 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
13059 }
13060 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));
13061 }
13062 GeneratedField::CompactionFilterMask => {
13063 if mutable_config__.is_some() {
13064 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
13065 }
13066 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));
13067 }
13068 GeneratedField::MaxSubCompaction => {
13069 if mutable_config__.is_some() {
13070 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
13071 }
13072 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));
13073 }
13074 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
13075 if mutable_config__.is_some() {
13076 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
13077 }
13078 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));
13079 }
13080 GeneratedField::Level0SubLevelCompactLevelCount => {
13081 if mutable_config__.is_some() {
13082 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
13083 }
13084 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));
13085 }
13086 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
13087 if mutable_config__.is_some() {
13088 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
13089 }
13090 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));
13091 }
13092 GeneratedField::MaxSpaceReclaimBytes => {
13093 if mutable_config__.is_some() {
13094 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
13095 }
13096 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));
13097 }
13098 GeneratedField::Level0MaxCompactFileNumber => {
13099 if mutable_config__.is_some() {
13100 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
13101 }
13102 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));
13103 }
13104 GeneratedField::EnableEmergencyPicker => {
13105 if mutable_config__.is_some() {
13106 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
13107 }
13108 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
13109 }
13110 GeneratedField::TombstoneReclaimRatio => {
13111 if mutable_config__.is_some() {
13112 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
13113 }
13114 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));
13115 }
13116 GeneratedField::CompressionAlgorithm => {
13117 if mutable_config__.is_some() {
13118 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13119 }
13120 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
13121;
13122 }
13123 GeneratedField::MaxL0CompactLevelCount => {
13124 if mutable_config__.is_some() {
13125 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
13126 }
13127 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));
13128 }
13129 GeneratedField::SstAllowedTrivialMoveMinSize => {
13130 if mutable_config__.is_some() {
13131 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
13132 }
13133 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));
13134 }
13135 GeneratedField::SplitWeightByVnode => {
13136 if mutable_config__.is_some() {
13137 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
13138 }
13139 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));
13140 }
13141 GeneratedField::DisableAutoGroupScheduling => {
13142 if mutable_config__.is_some() {
13143 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
13144 }
13145 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
13146 }
13147 GeneratedField::MaxOverlappingLevelSize => {
13148 if mutable_config__.is_some() {
13149 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
13150 }
13151 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));
13152 }
13153 GeneratedField::EmergencyLevel0SstFileCount => {
13154 if mutable_config__.is_some() {
13155 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
13156 }
13157 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));
13158 }
13159 GeneratedField::EmergencyLevel0SubLevelPartition => {
13160 if mutable_config__.is_some() {
13161 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
13162 }
13163 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));
13164 }
13165 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
13166 if mutable_config__.is_some() {
13167 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
13168 }
13169 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));
13170 }
13171 GeneratedField::Level0StopWriteThresholdMaxSize => {
13172 if mutable_config__.is_some() {
13173 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
13174 }
13175 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));
13176 }
13177 GeneratedField::SstAllowedTrivialMoveMaxCount => {
13178 if mutable_config__.is_some() {
13179 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
13180 }
13181 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));
13182 }
13183 GeneratedField::EnableOptimizeL0IntervalSelection => {
13184 if mutable_config__.is_some() {
13185 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
13186 }
13187 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
13188 }
13189 }
13190 }
13191 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
13192 mutable_config: mutable_config__,
13193 })
13194 }
13195 }
13196 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
13197 }
13198}
13199impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
13200 #[allow(deprecated)]
13201 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13202 where
13203 S: serde::Serializer,
13204 {
13205 use serde::ser::SerializeStruct;
13206 let mut len = 0;
13207 if self.status.is_some() {
13208 len += 1;
13209 }
13210 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
13211 if let Some(v) = self.status.as_ref() {
13212 struct_ser.serialize_field("status", v)?;
13213 }
13214 struct_ser.end()
13215 }
13216}
13217impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
13218 #[allow(deprecated)]
13219 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13220 where
13221 D: serde::Deserializer<'de>,
13222 {
13223 const FIELDS: &[&str] = &[
13224 "status",
13225 ];
13226
13227 #[allow(clippy::enum_variant_names)]
13228 enum GeneratedField {
13229 Status,
13230 }
13231 impl<'de> serde::Deserialize<'de> for GeneratedField {
13232 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13233 where
13234 D: serde::Deserializer<'de>,
13235 {
13236 struct GeneratedVisitor;
13237
13238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13239 type Value = GeneratedField;
13240
13241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13242 write!(formatter, "expected one of: {:?}", &FIELDS)
13243 }
13244
13245 #[allow(unused_variables)]
13246 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13247 where
13248 E: serde::de::Error,
13249 {
13250 match value {
13251 "status" => Ok(GeneratedField::Status),
13252 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13253 }
13254 }
13255 }
13256 deserializer.deserialize_identifier(GeneratedVisitor)
13257 }
13258 }
13259 struct GeneratedVisitor;
13260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13261 type Value = RiseCtlUpdateCompactionConfigResponse;
13262
13263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13264 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
13265 }
13266
13267 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
13268 where
13269 V: serde::de::MapAccess<'de>,
13270 {
13271 let mut status__ = None;
13272 while let Some(k) = map_.next_key()? {
13273 match k {
13274 GeneratedField::Status => {
13275 if status__.is_some() {
13276 return Err(serde::de::Error::duplicate_field("status"));
13277 }
13278 status__ = map_.next_value()?;
13279 }
13280 }
13281 }
13282 Ok(RiseCtlUpdateCompactionConfigResponse {
13283 status: status__,
13284 })
13285 }
13286 }
13287 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
13288 }
13289}
13290impl serde::Serialize for SplitCompactionGroupRequest {
13291 #[allow(deprecated)]
13292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13293 where
13294 S: serde::Serializer,
13295 {
13296 use serde::ser::SerializeStruct;
13297 let mut len = 0;
13298 if self.group_id != 0 {
13299 len += 1;
13300 }
13301 if !self.table_ids.is_empty() {
13302 len += 1;
13303 }
13304 if self.partition_vnode_count != 0 {
13305 len += 1;
13306 }
13307 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
13308 if self.group_id != 0 {
13309 #[allow(clippy::needless_borrow)]
13310 #[allow(clippy::needless_borrows_for_generic_args)]
13311 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
13312 }
13313 if !self.table_ids.is_empty() {
13314 struct_ser.serialize_field("tableIds", &self.table_ids)?;
13315 }
13316 if self.partition_vnode_count != 0 {
13317 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
13318 }
13319 struct_ser.end()
13320 }
13321}
13322impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
13323 #[allow(deprecated)]
13324 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13325 where
13326 D: serde::Deserializer<'de>,
13327 {
13328 const FIELDS: &[&str] = &[
13329 "group_id",
13330 "groupId",
13331 "table_ids",
13332 "tableIds",
13333 "partition_vnode_count",
13334 "partitionVnodeCount",
13335 ];
13336
13337 #[allow(clippy::enum_variant_names)]
13338 enum GeneratedField {
13339 GroupId,
13340 TableIds,
13341 PartitionVnodeCount,
13342 }
13343 impl<'de> serde::Deserialize<'de> for GeneratedField {
13344 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13345 where
13346 D: serde::Deserializer<'de>,
13347 {
13348 struct GeneratedVisitor;
13349
13350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13351 type Value = GeneratedField;
13352
13353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13354 write!(formatter, "expected one of: {:?}", &FIELDS)
13355 }
13356
13357 #[allow(unused_variables)]
13358 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13359 where
13360 E: serde::de::Error,
13361 {
13362 match value {
13363 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
13364 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13365 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
13366 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13367 }
13368 }
13369 }
13370 deserializer.deserialize_identifier(GeneratedVisitor)
13371 }
13372 }
13373 struct GeneratedVisitor;
13374 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13375 type Value = SplitCompactionGroupRequest;
13376
13377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13378 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
13379 }
13380
13381 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
13382 where
13383 V: serde::de::MapAccess<'de>,
13384 {
13385 let mut group_id__ = None;
13386 let mut table_ids__ = None;
13387 let mut partition_vnode_count__ = None;
13388 while let Some(k) = map_.next_key()? {
13389 match k {
13390 GeneratedField::GroupId => {
13391 if group_id__.is_some() {
13392 return Err(serde::de::Error::duplicate_field("groupId"));
13393 }
13394 group_id__ =
13395 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13396 ;
13397 }
13398 GeneratedField::TableIds => {
13399 if table_ids__.is_some() {
13400 return Err(serde::de::Error::duplicate_field("tableIds"));
13401 }
13402 table_ids__ =
13403 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13404 .into_iter().map(|x| x.0).collect())
13405 ;
13406 }
13407 GeneratedField::PartitionVnodeCount => {
13408 if partition_vnode_count__.is_some() {
13409 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
13410 }
13411 partition_vnode_count__ =
13412 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13413 ;
13414 }
13415 }
13416 }
13417 Ok(SplitCompactionGroupRequest {
13418 group_id: group_id__.unwrap_or_default(),
13419 table_ids: table_ids__.unwrap_or_default(),
13420 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
13421 })
13422 }
13423 }
13424 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
13425 }
13426}
13427impl serde::Serialize for SplitCompactionGroupResponse {
13428 #[allow(deprecated)]
13429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13430 where
13431 S: serde::Serializer,
13432 {
13433 use serde::ser::SerializeStruct;
13434 let mut len = 0;
13435 if self.new_group_id != 0 {
13436 len += 1;
13437 }
13438 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
13439 if self.new_group_id != 0 {
13440 #[allow(clippy::needless_borrow)]
13441 #[allow(clippy::needless_borrows_for_generic_args)]
13442 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
13443 }
13444 struct_ser.end()
13445 }
13446}
13447impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
13448 #[allow(deprecated)]
13449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13450 where
13451 D: serde::Deserializer<'de>,
13452 {
13453 const FIELDS: &[&str] = &[
13454 "new_group_id",
13455 "newGroupId",
13456 ];
13457
13458 #[allow(clippy::enum_variant_names)]
13459 enum GeneratedField {
13460 NewGroupId,
13461 }
13462 impl<'de> serde::Deserialize<'de> for GeneratedField {
13463 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13464 where
13465 D: serde::Deserializer<'de>,
13466 {
13467 struct GeneratedVisitor;
13468
13469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13470 type Value = GeneratedField;
13471
13472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13473 write!(formatter, "expected one of: {:?}", &FIELDS)
13474 }
13475
13476 #[allow(unused_variables)]
13477 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13478 where
13479 E: serde::de::Error,
13480 {
13481 match value {
13482 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
13483 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13484 }
13485 }
13486 }
13487 deserializer.deserialize_identifier(GeneratedVisitor)
13488 }
13489 }
13490 struct GeneratedVisitor;
13491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13492 type Value = SplitCompactionGroupResponse;
13493
13494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13495 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
13496 }
13497
13498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
13499 where
13500 V: serde::de::MapAccess<'de>,
13501 {
13502 let mut new_group_id__ = None;
13503 while let Some(k) = map_.next_key()? {
13504 match k {
13505 GeneratedField::NewGroupId => {
13506 if new_group_id__.is_some() {
13507 return Err(serde::de::Error::duplicate_field("newGroupId"));
13508 }
13509 new_group_id__ =
13510 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13511 ;
13512 }
13513 }
13514 }
13515 Ok(SplitCompactionGroupResponse {
13516 new_group_id: new_group_id__.unwrap_or_default(),
13517 })
13518 }
13519 }
13520 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
13521 }
13522}
13523impl serde::Serialize for SstableInfo {
13524 #[allow(deprecated)]
13525 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13526 where
13527 S: serde::Serializer,
13528 {
13529 use serde::ser::SerializeStruct;
13530 let mut len = 0;
13531 if self.object_id != 0 {
13532 len += 1;
13533 }
13534 if self.sst_id != 0 {
13535 len += 1;
13536 }
13537 if self.key_range.is_some() {
13538 len += 1;
13539 }
13540 if self.file_size != 0 {
13541 len += 1;
13542 }
13543 if !self.table_ids.is_empty() {
13544 len += 1;
13545 }
13546 if self.meta_offset != 0 {
13547 len += 1;
13548 }
13549 if self.stale_key_count != 0 {
13550 len += 1;
13551 }
13552 if self.total_key_count != 0 {
13553 len += 1;
13554 }
13555 if self.min_epoch != 0 {
13556 len += 1;
13557 }
13558 if self.max_epoch != 0 {
13559 len += 1;
13560 }
13561 if self.uncompressed_file_size != 0 {
13562 len += 1;
13563 }
13564 if self.range_tombstone_count != 0 {
13565 len += 1;
13566 }
13567 if self.bloom_filter_kind != 0 {
13568 len += 1;
13569 }
13570 if self.sst_size != 0 {
13571 len += 1;
13572 }
13573 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
13574 if self.object_id != 0 {
13575 #[allow(clippy::needless_borrow)]
13576 #[allow(clippy::needless_borrows_for_generic_args)]
13577 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
13578 }
13579 if self.sst_id != 0 {
13580 #[allow(clippy::needless_borrow)]
13581 #[allow(clippy::needless_borrows_for_generic_args)]
13582 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
13583 }
13584 if let Some(v) = self.key_range.as_ref() {
13585 struct_ser.serialize_field("keyRange", v)?;
13586 }
13587 if self.file_size != 0 {
13588 #[allow(clippy::needless_borrow)]
13589 #[allow(clippy::needless_borrows_for_generic_args)]
13590 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
13591 }
13592 if !self.table_ids.is_empty() {
13593 struct_ser.serialize_field("tableIds", &self.table_ids)?;
13594 }
13595 if self.meta_offset != 0 {
13596 #[allow(clippy::needless_borrow)]
13597 #[allow(clippy::needless_borrows_for_generic_args)]
13598 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
13599 }
13600 if self.stale_key_count != 0 {
13601 #[allow(clippy::needless_borrow)]
13602 #[allow(clippy::needless_borrows_for_generic_args)]
13603 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
13604 }
13605 if self.total_key_count != 0 {
13606 #[allow(clippy::needless_borrow)]
13607 #[allow(clippy::needless_borrows_for_generic_args)]
13608 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
13609 }
13610 if self.min_epoch != 0 {
13611 #[allow(clippy::needless_borrow)]
13612 #[allow(clippy::needless_borrows_for_generic_args)]
13613 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
13614 }
13615 if self.max_epoch != 0 {
13616 #[allow(clippy::needless_borrow)]
13617 #[allow(clippy::needless_borrows_for_generic_args)]
13618 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
13619 }
13620 if self.uncompressed_file_size != 0 {
13621 #[allow(clippy::needless_borrow)]
13622 #[allow(clippy::needless_borrows_for_generic_args)]
13623 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
13624 }
13625 if self.range_tombstone_count != 0 {
13626 #[allow(clippy::needless_borrow)]
13627 #[allow(clippy::needless_borrows_for_generic_args)]
13628 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
13629 }
13630 if self.bloom_filter_kind != 0 {
13631 let v = BloomFilterType::try_from(self.bloom_filter_kind)
13632 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
13633 struct_ser.serialize_field("bloomFilterKind", &v)?;
13634 }
13635 if self.sst_size != 0 {
13636 #[allow(clippy::needless_borrow)]
13637 #[allow(clippy::needless_borrows_for_generic_args)]
13638 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
13639 }
13640 struct_ser.end()
13641 }
13642}
13643impl<'de> serde::Deserialize<'de> for SstableInfo {
13644 #[allow(deprecated)]
13645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13646 where
13647 D: serde::Deserializer<'de>,
13648 {
13649 const FIELDS: &[&str] = &[
13650 "object_id",
13651 "objectId",
13652 "sst_id",
13653 "sstId",
13654 "key_range",
13655 "keyRange",
13656 "file_size",
13657 "fileSize",
13658 "table_ids",
13659 "tableIds",
13660 "meta_offset",
13661 "metaOffset",
13662 "stale_key_count",
13663 "staleKeyCount",
13664 "total_key_count",
13665 "totalKeyCount",
13666 "min_epoch",
13667 "minEpoch",
13668 "max_epoch",
13669 "maxEpoch",
13670 "uncompressed_file_size",
13671 "uncompressedFileSize",
13672 "range_tombstone_count",
13673 "rangeTombstoneCount",
13674 "bloom_filter_kind",
13675 "bloomFilterKind",
13676 "sst_size",
13677 "sstSize",
13678 ];
13679
13680 #[allow(clippy::enum_variant_names)]
13681 enum GeneratedField {
13682 ObjectId,
13683 SstId,
13684 KeyRange,
13685 FileSize,
13686 TableIds,
13687 MetaOffset,
13688 StaleKeyCount,
13689 TotalKeyCount,
13690 MinEpoch,
13691 MaxEpoch,
13692 UncompressedFileSize,
13693 RangeTombstoneCount,
13694 BloomFilterKind,
13695 SstSize,
13696 }
13697 impl<'de> serde::Deserialize<'de> for GeneratedField {
13698 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13699 where
13700 D: serde::Deserializer<'de>,
13701 {
13702 struct GeneratedVisitor;
13703
13704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13705 type Value = GeneratedField;
13706
13707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13708 write!(formatter, "expected one of: {:?}", &FIELDS)
13709 }
13710
13711 #[allow(unused_variables)]
13712 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13713 where
13714 E: serde::de::Error,
13715 {
13716 match value {
13717 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
13718 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
13719 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
13720 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
13721 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13722 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
13723 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
13724 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
13725 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
13726 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
13727 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
13728 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
13729 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
13730 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
13731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13732 }
13733 }
13734 }
13735 deserializer.deserialize_identifier(GeneratedVisitor)
13736 }
13737 }
13738 struct GeneratedVisitor;
13739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13740 type Value = SstableInfo;
13741
13742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13743 formatter.write_str("struct hummock.SstableInfo")
13744 }
13745
13746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
13747 where
13748 V: serde::de::MapAccess<'de>,
13749 {
13750 let mut object_id__ = None;
13751 let mut sst_id__ = None;
13752 let mut key_range__ = None;
13753 let mut file_size__ = None;
13754 let mut table_ids__ = None;
13755 let mut meta_offset__ = None;
13756 let mut stale_key_count__ = None;
13757 let mut total_key_count__ = None;
13758 let mut min_epoch__ = None;
13759 let mut max_epoch__ = None;
13760 let mut uncompressed_file_size__ = None;
13761 let mut range_tombstone_count__ = None;
13762 let mut bloom_filter_kind__ = None;
13763 let mut sst_size__ = None;
13764 while let Some(k) = map_.next_key()? {
13765 match k {
13766 GeneratedField::ObjectId => {
13767 if object_id__.is_some() {
13768 return Err(serde::de::Error::duplicate_field("objectId"));
13769 }
13770 object_id__ =
13771 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13772 ;
13773 }
13774 GeneratedField::SstId => {
13775 if sst_id__.is_some() {
13776 return Err(serde::de::Error::duplicate_field("sstId"));
13777 }
13778 sst_id__ =
13779 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13780 ;
13781 }
13782 GeneratedField::KeyRange => {
13783 if key_range__.is_some() {
13784 return Err(serde::de::Error::duplicate_field("keyRange"));
13785 }
13786 key_range__ = map_.next_value()?;
13787 }
13788 GeneratedField::FileSize => {
13789 if file_size__.is_some() {
13790 return Err(serde::de::Error::duplicate_field("fileSize"));
13791 }
13792 file_size__ =
13793 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13794 ;
13795 }
13796 GeneratedField::TableIds => {
13797 if table_ids__.is_some() {
13798 return Err(serde::de::Error::duplicate_field("tableIds"));
13799 }
13800 table_ids__ =
13801 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13802 .into_iter().map(|x| x.0).collect())
13803 ;
13804 }
13805 GeneratedField::MetaOffset => {
13806 if meta_offset__.is_some() {
13807 return Err(serde::de::Error::duplicate_field("metaOffset"));
13808 }
13809 meta_offset__ =
13810 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13811 ;
13812 }
13813 GeneratedField::StaleKeyCount => {
13814 if stale_key_count__.is_some() {
13815 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
13816 }
13817 stale_key_count__ =
13818 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13819 ;
13820 }
13821 GeneratedField::TotalKeyCount => {
13822 if total_key_count__.is_some() {
13823 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
13824 }
13825 total_key_count__ =
13826 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13827 ;
13828 }
13829 GeneratedField::MinEpoch => {
13830 if min_epoch__.is_some() {
13831 return Err(serde::de::Error::duplicate_field("minEpoch"));
13832 }
13833 min_epoch__ =
13834 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13835 ;
13836 }
13837 GeneratedField::MaxEpoch => {
13838 if max_epoch__.is_some() {
13839 return Err(serde::de::Error::duplicate_field("maxEpoch"));
13840 }
13841 max_epoch__ =
13842 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13843 ;
13844 }
13845 GeneratedField::UncompressedFileSize => {
13846 if uncompressed_file_size__.is_some() {
13847 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
13848 }
13849 uncompressed_file_size__ =
13850 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13851 ;
13852 }
13853 GeneratedField::RangeTombstoneCount => {
13854 if range_tombstone_count__.is_some() {
13855 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
13856 }
13857 range_tombstone_count__ =
13858 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13859 ;
13860 }
13861 GeneratedField::BloomFilterKind => {
13862 if bloom_filter_kind__.is_some() {
13863 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
13864 }
13865 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
13866 }
13867 GeneratedField::SstSize => {
13868 if sst_size__.is_some() {
13869 return Err(serde::de::Error::duplicate_field("sstSize"));
13870 }
13871 sst_size__ =
13872 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13873 ;
13874 }
13875 }
13876 }
13877 Ok(SstableInfo {
13878 object_id: object_id__.unwrap_or_default(),
13879 sst_id: sst_id__.unwrap_or_default(),
13880 key_range: key_range__,
13881 file_size: file_size__.unwrap_or_default(),
13882 table_ids: table_ids__.unwrap_or_default(),
13883 meta_offset: meta_offset__.unwrap_or_default(),
13884 stale_key_count: stale_key_count__.unwrap_or_default(),
13885 total_key_count: total_key_count__.unwrap_or_default(),
13886 min_epoch: min_epoch__.unwrap_or_default(),
13887 max_epoch: max_epoch__.unwrap_or_default(),
13888 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
13889 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
13890 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
13891 sst_size: sst_size__.unwrap_or_default(),
13892 })
13893 }
13894 }
13895 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
13896 }
13897}
13898impl serde::Serialize for StateTableInfo {
13899 #[allow(deprecated)]
13900 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13901 where
13902 S: serde::Serializer,
13903 {
13904 use serde::ser::SerializeStruct;
13905 let mut len = 0;
13906 if self.committed_epoch != 0 {
13907 len += 1;
13908 }
13909 if self.compaction_group_id != 0 {
13910 len += 1;
13911 }
13912 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
13913 if self.committed_epoch != 0 {
13914 #[allow(clippy::needless_borrow)]
13915 #[allow(clippy::needless_borrows_for_generic_args)]
13916 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13917 }
13918 if self.compaction_group_id != 0 {
13919 #[allow(clippy::needless_borrow)]
13920 #[allow(clippy::needless_borrows_for_generic_args)]
13921 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13922 }
13923 struct_ser.end()
13924 }
13925}
13926impl<'de> serde::Deserialize<'de> for StateTableInfo {
13927 #[allow(deprecated)]
13928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13929 where
13930 D: serde::Deserializer<'de>,
13931 {
13932 const FIELDS: &[&str] = &[
13933 "committed_epoch",
13934 "committedEpoch",
13935 "compaction_group_id",
13936 "compactionGroupId",
13937 ];
13938
13939 #[allow(clippy::enum_variant_names)]
13940 enum GeneratedField {
13941 CommittedEpoch,
13942 CompactionGroupId,
13943 }
13944 impl<'de> serde::Deserialize<'de> for GeneratedField {
13945 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13946 where
13947 D: serde::Deserializer<'de>,
13948 {
13949 struct GeneratedVisitor;
13950
13951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13952 type Value = GeneratedField;
13953
13954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13955 write!(formatter, "expected one of: {:?}", &FIELDS)
13956 }
13957
13958 #[allow(unused_variables)]
13959 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13960 where
13961 E: serde::de::Error,
13962 {
13963 match value {
13964 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13965 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13966 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13967 }
13968 }
13969 }
13970 deserializer.deserialize_identifier(GeneratedVisitor)
13971 }
13972 }
13973 struct GeneratedVisitor;
13974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13975 type Value = StateTableInfo;
13976
13977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13978 formatter.write_str("struct hummock.StateTableInfo")
13979 }
13980
13981 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
13982 where
13983 V: serde::de::MapAccess<'de>,
13984 {
13985 let mut committed_epoch__ = None;
13986 let mut compaction_group_id__ = None;
13987 while let Some(k) = map_.next_key()? {
13988 match k {
13989 GeneratedField::CommittedEpoch => {
13990 if committed_epoch__.is_some() {
13991 return Err(serde::de::Error::duplicate_field("committedEpoch"));
13992 }
13993 committed_epoch__ =
13994 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13995 ;
13996 }
13997 GeneratedField::CompactionGroupId => {
13998 if compaction_group_id__.is_some() {
13999 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14000 }
14001 compaction_group_id__ =
14002 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14003 ;
14004 }
14005 }
14006 }
14007 Ok(StateTableInfo {
14008 committed_epoch: committed_epoch__.unwrap_or_default(),
14009 compaction_group_id: compaction_group_id__.unwrap_or_default(),
14010 })
14011 }
14012 }
14013 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
14014 }
14015}
14016impl serde::Serialize for StateTableInfoDelta {
14017 #[allow(deprecated)]
14018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14019 where
14020 S: serde::Serializer,
14021 {
14022 use serde::ser::SerializeStruct;
14023 let mut len = 0;
14024 if self.committed_epoch != 0 {
14025 len += 1;
14026 }
14027 if self.compaction_group_id != 0 {
14028 len += 1;
14029 }
14030 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
14031 if self.committed_epoch != 0 {
14032 #[allow(clippy::needless_borrow)]
14033 #[allow(clippy::needless_borrows_for_generic_args)]
14034 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
14035 }
14036 if self.compaction_group_id != 0 {
14037 #[allow(clippy::needless_borrow)]
14038 #[allow(clippy::needless_borrows_for_generic_args)]
14039 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
14040 }
14041 struct_ser.end()
14042 }
14043}
14044impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
14045 #[allow(deprecated)]
14046 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14047 where
14048 D: serde::Deserializer<'de>,
14049 {
14050 const FIELDS: &[&str] = &[
14051 "committed_epoch",
14052 "committedEpoch",
14053 "compaction_group_id",
14054 "compactionGroupId",
14055 ];
14056
14057 #[allow(clippy::enum_variant_names)]
14058 enum GeneratedField {
14059 CommittedEpoch,
14060 CompactionGroupId,
14061 }
14062 impl<'de> serde::Deserialize<'de> for GeneratedField {
14063 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14064 where
14065 D: serde::Deserializer<'de>,
14066 {
14067 struct GeneratedVisitor;
14068
14069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14070 type Value = GeneratedField;
14071
14072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14073 write!(formatter, "expected one of: {:?}", &FIELDS)
14074 }
14075
14076 #[allow(unused_variables)]
14077 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14078 where
14079 E: serde::de::Error,
14080 {
14081 match value {
14082 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
14083 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
14084 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14085 }
14086 }
14087 }
14088 deserializer.deserialize_identifier(GeneratedVisitor)
14089 }
14090 }
14091 struct GeneratedVisitor;
14092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14093 type Value = StateTableInfoDelta;
14094
14095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14096 formatter.write_str("struct hummock.StateTableInfoDelta")
14097 }
14098
14099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
14100 where
14101 V: serde::de::MapAccess<'de>,
14102 {
14103 let mut committed_epoch__ = None;
14104 let mut compaction_group_id__ = None;
14105 while let Some(k) = map_.next_key()? {
14106 match k {
14107 GeneratedField::CommittedEpoch => {
14108 if committed_epoch__.is_some() {
14109 return Err(serde::de::Error::duplicate_field("committedEpoch"));
14110 }
14111 committed_epoch__ =
14112 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14113 ;
14114 }
14115 GeneratedField::CompactionGroupId => {
14116 if compaction_group_id__.is_some() {
14117 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14118 }
14119 compaction_group_id__ =
14120 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14121 ;
14122 }
14123 }
14124 }
14125 Ok(StateTableInfoDelta {
14126 committed_epoch: committed_epoch__.unwrap_or_default(),
14127 compaction_group_id: compaction_group_id__.unwrap_or_default(),
14128 })
14129 }
14130 }
14131 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
14132 }
14133}
14134impl serde::Serialize for SubscribeCompactionEventRequest {
14135 #[allow(deprecated)]
14136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14137 where
14138 S: serde::Serializer,
14139 {
14140 use serde::ser::SerializeStruct;
14141 let mut len = 0;
14142 if self.create_at != 0 {
14143 len += 1;
14144 }
14145 if self.event.is_some() {
14146 len += 1;
14147 }
14148 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
14149 if self.create_at != 0 {
14150 #[allow(clippy::needless_borrow)]
14151 #[allow(clippy::needless_borrows_for_generic_args)]
14152 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14153 }
14154 if let Some(v) = self.event.as_ref() {
14155 match v {
14156 subscribe_compaction_event_request::Event::Register(v) => {
14157 struct_ser.serialize_field("register", v)?;
14158 }
14159 subscribe_compaction_event_request::Event::PullTask(v) => {
14160 struct_ser.serialize_field("pullTask", v)?;
14161 }
14162 subscribe_compaction_event_request::Event::ReportTask(v) => {
14163 struct_ser.serialize_field("reportTask", v)?;
14164 }
14165 subscribe_compaction_event_request::Event::HeartBeat(v) => {
14166 struct_ser.serialize_field("heartBeat", v)?;
14167 }
14168 }
14169 }
14170 struct_ser.end()
14171 }
14172}
14173impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
14174 #[allow(deprecated)]
14175 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14176 where
14177 D: serde::Deserializer<'de>,
14178 {
14179 const FIELDS: &[&str] = &[
14180 "create_at",
14181 "createAt",
14182 "register",
14183 "pull_task",
14184 "pullTask",
14185 "report_task",
14186 "reportTask",
14187 "heart_beat",
14188 "heartBeat",
14189 ];
14190
14191 #[allow(clippy::enum_variant_names)]
14192 enum GeneratedField {
14193 CreateAt,
14194 Register,
14195 PullTask,
14196 ReportTask,
14197 HeartBeat,
14198 }
14199 impl<'de> serde::Deserialize<'de> for GeneratedField {
14200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14201 where
14202 D: serde::Deserializer<'de>,
14203 {
14204 struct GeneratedVisitor;
14205
14206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14207 type Value = GeneratedField;
14208
14209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14210 write!(formatter, "expected one of: {:?}", &FIELDS)
14211 }
14212
14213 #[allow(unused_variables)]
14214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14215 where
14216 E: serde::de::Error,
14217 {
14218 match value {
14219 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14220 "register" => Ok(GeneratedField::Register),
14221 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
14222 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
14223 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
14224 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14225 }
14226 }
14227 }
14228 deserializer.deserialize_identifier(GeneratedVisitor)
14229 }
14230 }
14231 struct GeneratedVisitor;
14232 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14233 type Value = SubscribeCompactionEventRequest;
14234
14235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14236 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
14237 }
14238
14239 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
14240 where
14241 V: serde::de::MapAccess<'de>,
14242 {
14243 let mut create_at__ = None;
14244 let mut event__ = None;
14245 while let Some(k) = map_.next_key()? {
14246 match k {
14247 GeneratedField::CreateAt => {
14248 if create_at__.is_some() {
14249 return Err(serde::de::Error::duplicate_field("createAt"));
14250 }
14251 create_at__ =
14252 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14253 ;
14254 }
14255 GeneratedField::Register => {
14256 if event__.is_some() {
14257 return Err(serde::de::Error::duplicate_field("register"));
14258 }
14259 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
14260;
14261 }
14262 GeneratedField::PullTask => {
14263 if event__.is_some() {
14264 return Err(serde::de::Error::duplicate_field("pullTask"));
14265 }
14266 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
14267;
14268 }
14269 GeneratedField::ReportTask => {
14270 if event__.is_some() {
14271 return Err(serde::de::Error::duplicate_field("reportTask"));
14272 }
14273 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
14274;
14275 }
14276 GeneratedField::HeartBeat => {
14277 if event__.is_some() {
14278 return Err(serde::de::Error::duplicate_field("heartBeat"));
14279 }
14280 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
14281;
14282 }
14283 }
14284 }
14285 Ok(SubscribeCompactionEventRequest {
14286 create_at: create_at__.unwrap_or_default(),
14287 event: event__,
14288 })
14289 }
14290 }
14291 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
14292 }
14293}
14294impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
14295 #[allow(deprecated)]
14296 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14297 where
14298 S: serde::Serializer,
14299 {
14300 use serde::ser::SerializeStruct;
14301 let mut len = 0;
14302 if !self.progress.is_empty() {
14303 len += 1;
14304 }
14305 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
14306 if !self.progress.is_empty() {
14307 struct_ser.serialize_field("progress", &self.progress)?;
14308 }
14309 struct_ser.end()
14310 }
14311}
14312impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
14313 #[allow(deprecated)]
14314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14315 where
14316 D: serde::Deserializer<'de>,
14317 {
14318 const FIELDS: &[&str] = &[
14319 "progress",
14320 ];
14321
14322 #[allow(clippy::enum_variant_names)]
14323 enum GeneratedField {
14324 Progress,
14325 }
14326 impl<'de> serde::Deserialize<'de> for GeneratedField {
14327 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14328 where
14329 D: serde::Deserializer<'de>,
14330 {
14331 struct GeneratedVisitor;
14332
14333 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14334 type Value = GeneratedField;
14335
14336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14337 write!(formatter, "expected one of: {:?}", &FIELDS)
14338 }
14339
14340 #[allow(unused_variables)]
14341 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14342 where
14343 E: serde::de::Error,
14344 {
14345 match value {
14346 "progress" => Ok(GeneratedField::Progress),
14347 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14348 }
14349 }
14350 }
14351 deserializer.deserialize_identifier(GeneratedVisitor)
14352 }
14353 }
14354 struct GeneratedVisitor;
14355 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14356 type Value = subscribe_compaction_event_request::HeartBeat;
14357
14358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14359 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
14360 }
14361
14362 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
14363 where
14364 V: serde::de::MapAccess<'de>,
14365 {
14366 let mut progress__ = None;
14367 while let Some(k) = map_.next_key()? {
14368 match k {
14369 GeneratedField::Progress => {
14370 if progress__.is_some() {
14371 return Err(serde::de::Error::duplicate_field("progress"));
14372 }
14373 progress__ = Some(map_.next_value()?);
14374 }
14375 }
14376 }
14377 Ok(subscribe_compaction_event_request::HeartBeat {
14378 progress: progress__.unwrap_or_default(),
14379 })
14380 }
14381 }
14382 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
14383 }
14384}
14385impl serde::Serialize for subscribe_compaction_event_request::PullTask {
14386 #[allow(deprecated)]
14387 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14388 where
14389 S: serde::Serializer,
14390 {
14391 use serde::ser::SerializeStruct;
14392 let mut len = 0;
14393 if self.pull_task_count != 0 {
14394 len += 1;
14395 }
14396 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
14397 if self.pull_task_count != 0 {
14398 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
14399 }
14400 struct_ser.end()
14401 }
14402}
14403impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
14404 #[allow(deprecated)]
14405 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14406 where
14407 D: serde::Deserializer<'de>,
14408 {
14409 const FIELDS: &[&str] = &[
14410 "pull_task_count",
14411 "pullTaskCount",
14412 ];
14413
14414 #[allow(clippy::enum_variant_names)]
14415 enum GeneratedField {
14416 PullTaskCount,
14417 }
14418 impl<'de> serde::Deserialize<'de> for GeneratedField {
14419 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14420 where
14421 D: serde::Deserializer<'de>,
14422 {
14423 struct GeneratedVisitor;
14424
14425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14426 type Value = GeneratedField;
14427
14428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14429 write!(formatter, "expected one of: {:?}", &FIELDS)
14430 }
14431
14432 #[allow(unused_variables)]
14433 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14434 where
14435 E: serde::de::Error,
14436 {
14437 match value {
14438 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
14439 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14440 }
14441 }
14442 }
14443 deserializer.deserialize_identifier(GeneratedVisitor)
14444 }
14445 }
14446 struct GeneratedVisitor;
14447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14448 type Value = subscribe_compaction_event_request::PullTask;
14449
14450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14451 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
14452 }
14453
14454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
14455 where
14456 V: serde::de::MapAccess<'de>,
14457 {
14458 let mut pull_task_count__ = None;
14459 while let Some(k) = map_.next_key()? {
14460 match k {
14461 GeneratedField::PullTaskCount => {
14462 if pull_task_count__.is_some() {
14463 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
14464 }
14465 pull_task_count__ =
14466 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14467 ;
14468 }
14469 }
14470 }
14471 Ok(subscribe_compaction_event_request::PullTask {
14472 pull_task_count: pull_task_count__.unwrap_or_default(),
14473 })
14474 }
14475 }
14476 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
14477 }
14478}
14479impl serde::Serialize for subscribe_compaction_event_request::Register {
14480 #[allow(deprecated)]
14481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14482 where
14483 S: serde::Serializer,
14484 {
14485 use serde::ser::SerializeStruct;
14486 let mut len = 0;
14487 if self.context_id != 0 {
14488 len += 1;
14489 }
14490 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
14491 if self.context_id != 0 {
14492 struct_ser.serialize_field("contextId", &self.context_id)?;
14493 }
14494 struct_ser.end()
14495 }
14496}
14497impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
14498 #[allow(deprecated)]
14499 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14500 where
14501 D: serde::Deserializer<'de>,
14502 {
14503 const FIELDS: &[&str] = &[
14504 "context_id",
14505 "contextId",
14506 ];
14507
14508 #[allow(clippy::enum_variant_names)]
14509 enum GeneratedField {
14510 ContextId,
14511 }
14512 impl<'de> serde::Deserialize<'de> for GeneratedField {
14513 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14514 where
14515 D: serde::Deserializer<'de>,
14516 {
14517 struct GeneratedVisitor;
14518
14519 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14520 type Value = GeneratedField;
14521
14522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14523 write!(formatter, "expected one of: {:?}", &FIELDS)
14524 }
14525
14526 #[allow(unused_variables)]
14527 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14528 where
14529 E: serde::de::Error,
14530 {
14531 match value {
14532 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
14533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14534 }
14535 }
14536 }
14537 deserializer.deserialize_identifier(GeneratedVisitor)
14538 }
14539 }
14540 struct GeneratedVisitor;
14541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14542 type Value = subscribe_compaction_event_request::Register;
14543
14544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14545 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
14546 }
14547
14548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
14549 where
14550 V: serde::de::MapAccess<'de>,
14551 {
14552 let mut context_id__ = None;
14553 while let Some(k) = map_.next_key()? {
14554 match k {
14555 GeneratedField::ContextId => {
14556 if context_id__.is_some() {
14557 return Err(serde::de::Error::duplicate_field("contextId"));
14558 }
14559 context_id__ =
14560 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14561 ;
14562 }
14563 }
14564 }
14565 Ok(subscribe_compaction_event_request::Register {
14566 context_id: context_id__.unwrap_or_default(),
14567 })
14568 }
14569 }
14570 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
14571 }
14572}
14573impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
14574 #[allow(deprecated)]
14575 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14576 where
14577 S: serde::Serializer,
14578 {
14579 use serde::ser::SerializeStruct;
14580 let mut len = 0;
14581 if !self.table_stats_change.is_empty() {
14582 len += 1;
14583 }
14584 if self.task_id != 0 {
14585 len += 1;
14586 }
14587 if self.task_status != 0 {
14588 len += 1;
14589 }
14590 if !self.sorted_output_ssts.is_empty() {
14591 len += 1;
14592 }
14593 if !self.object_timestamps.is_empty() {
14594 len += 1;
14595 }
14596 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
14597 if !self.table_stats_change.is_empty() {
14598 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
14599 }
14600 if self.task_id != 0 {
14601 #[allow(clippy::needless_borrow)]
14602 #[allow(clippy::needless_borrows_for_generic_args)]
14603 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
14604 }
14605 if self.task_status != 0 {
14606 let v = compact_task::TaskStatus::try_from(self.task_status)
14607 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
14608 struct_ser.serialize_field("taskStatus", &v)?;
14609 }
14610 if !self.sorted_output_ssts.is_empty() {
14611 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
14612 }
14613 if !self.object_timestamps.is_empty() {
14614 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
14615 .map(|(k, v)| (k, v.to_string())).collect();
14616 struct_ser.serialize_field("objectTimestamps", &v)?;
14617 }
14618 struct_ser.end()
14619 }
14620}
14621impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
14622 #[allow(deprecated)]
14623 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14624 where
14625 D: serde::Deserializer<'de>,
14626 {
14627 const FIELDS: &[&str] = &[
14628 "table_stats_change",
14629 "tableStatsChange",
14630 "task_id",
14631 "taskId",
14632 "task_status",
14633 "taskStatus",
14634 "sorted_output_ssts",
14635 "sortedOutputSsts",
14636 "object_timestamps",
14637 "objectTimestamps",
14638 ];
14639
14640 #[allow(clippy::enum_variant_names)]
14641 enum GeneratedField {
14642 TableStatsChange,
14643 TaskId,
14644 TaskStatus,
14645 SortedOutputSsts,
14646 ObjectTimestamps,
14647 }
14648 impl<'de> serde::Deserialize<'de> for GeneratedField {
14649 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14650 where
14651 D: serde::Deserializer<'de>,
14652 {
14653 struct GeneratedVisitor;
14654
14655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14656 type Value = GeneratedField;
14657
14658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14659 write!(formatter, "expected one of: {:?}", &FIELDS)
14660 }
14661
14662 #[allow(unused_variables)]
14663 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14664 where
14665 E: serde::de::Error,
14666 {
14667 match value {
14668 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
14669 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
14670 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
14671 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
14672 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
14673 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14674 }
14675 }
14676 }
14677 deserializer.deserialize_identifier(GeneratedVisitor)
14678 }
14679 }
14680 struct GeneratedVisitor;
14681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14682 type Value = subscribe_compaction_event_request::ReportTask;
14683
14684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14685 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
14686 }
14687
14688 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
14689 where
14690 V: serde::de::MapAccess<'de>,
14691 {
14692 let mut table_stats_change__ = None;
14693 let mut task_id__ = None;
14694 let mut task_status__ = None;
14695 let mut sorted_output_ssts__ = None;
14696 let mut object_timestamps__ = None;
14697 while let Some(k) = map_.next_key()? {
14698 match k {
14699 GeneratedField::TableStatsChange => {
14700 if table_stats_change__.is_some() {
14701 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
14702 }
14703 table_stats_change__ = Some(
14704 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14705 .into_iter().map(|(k,v)| (k.0, v)).collect()
14706 );
14707 }
14708 GeneratedField::TaskId => {
14709 if task_id__.is_some() {
14710 return Err(serde::de::Error::duplicate_field("taskId"));
14711 }
14712 task_id__ =
14713 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14714 ;
14715 }
14716 GeneratedField::TaskStatus => {
14717 if task_status__.is_some() {
14718 return Err(serde::de::Error::duplicate_field("taskStatus"));
14719 }
14720 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
14721 }
14722 GeneratedField::SortedOutputSsts => {
14723 if sorted_output_ssts__.is_some() {
14724 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
14725 }
14726 sorted_output_ssts__ = Some(map_.next_value()?);
14727 }
14728 GeneratedField::ObjectTimestamps => {
14729 if object_timestamps__.is_some() {
14730 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
14731 }
14732 object_timestamps__ = Some(
14733 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14734 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
14735 );
14736 }
14737 }
14738 }
14739 Ok(subscribe_compaction_event_request::ReportTask {
14740 table_stats_change: table_stats_change__.unwrap_or_default(),
14741 task_id: task_id__.unwrap_or_default(),
14742 task_status: task_status__.unwrap_or_default(),
14743 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
14744 object_timestamps: object_timestamps__.unwrap_or_default(),
14745 })
14746 }
14747 }
14748 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
14749 }
14750}
14751impl serde::Serialize for SubscribeCompactionEventResponse {
14752 #[allow(deprecated)]
14753 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14754 where
14755 S: serde::Serializer,
14756 {
14757 use serde::ser::SerializeStruct;
14758 let mut len = 0;
14759 if self.create_at != 0 {
14760 len += 1;
14761 }
14762 if self.event.is_some() {
14763 len += 1;
14764 }
14765 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
14766 if self.create_at != 0 {
14767 #[allow(clippy::needless_borrow)]
14768 #[allow(clippy::needless_borrows_for_generic_args)]
14769 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14770 }
14771 if let Some(v) = self.event.as_ref() {
14772 match v {
14773 subscribe_compaction_event_response::Event::CompactTask(v) => {
14774 struct_ser.serialize_field("compactTask", v)?;
14775 }
14776 subscribe_compaction_event_response::Event::VacuumTask(v) => {
14777 struct_ser.serialize_field("vacuumTask", v)?;
14778 }
14779 subscribe_compaction_event_response::Event::FullScanTask(v) => {
14780 struct_ser.serialize_field("fullScanTask", v)?;
14781 }
14782 subscribe_compaction_event_response::Event::ValidationTask(v) => {
14783 struct_ser.serialize_field("validationTask", v)?;
14784 }
14785 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
14786 struct_ser.serialize_field("cancelCompactTask", v)?;
14787 }
14788 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
14789 struct_ser.serialize_field("pullTaskAck", v)?;
14790 }
14791 }
14792 }
14793 struct_ser.end()
14794 }
14795}
14796impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
14797 #[allow(deprecated)]
14798 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14799 where
14800 D: serde::Deserializer<'de>,
14801 {
14802 const FIELDS: &[&str] = &[
14803 "create_at",
14804 "createAt",
14805 "compact_task",
14806 "compactTask",
14807 "vacuum_task",
14808 "vacuumTask",
14809 "full_scan_task",
14810 "fullScanTask",
14811 "validation_task",
14812 "validationTask",
14813 "cancel_compact_task",
14814 "cancelCompactTask",
14815 "pull_task_ack",
14816 "pullTaskAck",
14817 ];
14818
14819 #[allow(clippy::enum_variant_names)]
14820 enum GeneratedField {
14821 CreateAt,
14822 CompactTask,
14823 VacuumTask,
14824 FullScanTask,
14825 ValidationTask,
14826 CancelCompactTask,
14827 PullTaskAck,
14828 }
14829 impl<'de> serde::Deserialize<'de> for GeneratedField {
14830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14831 where
14832 D: serde::Deserializer<'de>,
14833 {
14834 struct GeneratedVisitor;
14835
14836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14837 type Value = GeneratedField;
14838
14839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14840 write!(formatter, "expected one of: {:?}", &FIELDS)
14841 }
14842
14843 #[allow(unused_variables)]
14844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14845 where
14846 E: serde::de::Error,
14847 {
14848 match value {
14849 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14850 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
14851 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
14852 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
14853 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
14854 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
14855 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
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 = SubscribeCompactionEventResponse;
14866
14867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14868 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
14869 }
14870
14871 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
14872 where
14873 V: serde::de::MapAccess<'de>,
14874 {
14875 let mut create_at__ = None;
14876 let mut event__ = None;
14877 while let Some(k) = map_.next_key()? {
14878 match k {
14879 GeneratedField::CreateAt => {
14880 if create_at__.is_some() {
14881 return Err(serde::de::Error::duplicate_field("createAt"));
14882 }
14883 create_at__ =
14884 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14885 ;
14886 }
14887 GeneratedField::CompactTask => {
14888 if event__.is_some() {
14889 return Err(serde::de::Error::duplicate_field("compactTask"));
14890 }
14891 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
14892;
14893 }
14894 GeneratedField::VacuumTask => {
14895 if event__.is_some() {
14896 return Err(serde::de::Error::duplicate_field("vacuumTask"));
14897 }
14898 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
14899;
14900 }
14901 GeneratedField::FullScanTask => {
14902 if event__.is_some() {
14903 return Err(serde::de::Error::duplicate_field("fullScanTask"));
14904 }
14905 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
14906;
14907 }
14908 GeneratedField::ValidationTask => {
14909 if event__.is_some() {
14910 return Err(serde::de::Error::duplicate_field("validationTask"));
14911 }
14912 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
14913;
14914 }
14915 GeneratedField::CancelCompactTask => {
14916 if event__.is_some() {
14917 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
14918 }
14919 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
14920;
14921 }
14922 GeneratedField::PullTaskAck => {
14923 if event__.is_some() {
14924 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
14925 }
14926 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
14927;
14928 }
14929 }
14930 }
14931 Ok(SubscribeCompactionEventResponse {
14932 create_at: create_at__.unwrap_or_default(),
14933 event: event__,
14934 })
14935 }
14936 }
14937 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
14938 }
14939}
14940impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
14941 #[allow(deprecated)]
14942 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14943 where
14944 S: serde::Serializer,
14945 {
14946 use serde::ser::SerializeStruct;
14947 let len = 0;
14948 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
14949 struct_ser.end()
14950 }
14951}
14952impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
14953 #[allow(deprecated)]
14954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14955 where
14956 D: serde::Deserializer<'de>,
14957 {
14958 const FIELDS: &[&str] = &[
14959 ];
14960
14961 #[allow(clippy::enum_variant_names)]
14962 enum GeneratedField {
14963 }
14964 impl<'de> serde::Deserialize<'de> for GeneratedField {
14965 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14966 where
14967 D: serde::Deserializer<'de>,
14968 {
14969 struct GeneratedVisitor;
14970
14971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14972 type Value = GeneratedField;
14973
14974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14975 write!(formatter, "expected one of: {:?}", &FIELDS)
14976 }
14977
14978 #[allow(unused_variables)]
14979 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14980 where
14981 E: serde::de::Error,
14982 {
14983 Err(serde::de::Error::unknown_field(value, FIELDS))
14984 }
14985 }
14986 deserializer.deserialize_identifier(GeneratedVisitor)
14987 }
14988 }
14989 struct GeneratedVisitor;
14990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14991 type Value = subscribe_compaction_event_response::PullTaskAck;
14992
14993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14994 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
14995 }
14996
14997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
14998 where
14999 V: serde::de::MapAccess<'de>,
15000 {
15001 while map_.next_key::<GeneratedField>()?.is_some() {
15002 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15003 }
15004 Ok(subscribe_compaction_event_response::PullTaskAck {
15005 })
15006 }
15007 }
15008 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
15009 }
15010}
15011impl serde::Serialize for TableChangeLog {
15012 #[allow(deprecated)]
15013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15014 where
15015 S: serde::Serializer,
15016 {
15017 use serde::ser::SerializeStruct;
15018 let mut len = 0;
15019 if !self.change_logs.is_empty() {
15020 len += 1;
15021 }
15022 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
15023 if !self.change_logs.is_empty() {
15024 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
15025 }
15026 struct_ser.end()
15027 }
15028}
15029impl<'de> serde::Deserialize<'de> for TableChangeLog {
15030 #[allow(deprecated)]
15031 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15032 where
15033 D: serde::Deserializer<'de>,
15034 {
15035 const FIELDS: &[&str] = &[
15036 "change_logs",
15037 "changeLogs",
15038 ];
15039
15040 #[allow(clippy::enum_variant_names)]
15041 enum GeneratedField {
15042 ChangeLogs,
15043 }
15044 impl<'de> serde::Deserialize<'de> for GeneratedField {
15045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15046 where
15047 D: serde::Deserializer<'de>,
15048 {
15049 struct GeneratedVisitor;
15050
15051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15052 type Value = GeneratedField;
15053
15054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15055 write!(formatter, "expected one of: {:?}", &FIELDS)
15056 }
15057
15058 #[allow(unused_variables)]
15059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15060 where
15061 E: serde::de::Error,
15062 {
15063 match value {
15064 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
15065 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15066 }
15067 }
15068 }
15069 deserializer.deserialize_identifier(GeneratedVisitor)
15070 }
15071 }
15072 struct GeneratedVisitor;
15073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15074 type Value = TableChangeLog;
15075
15076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15077 formatter.write_str("struct hummock.TableChangeLog")
15078 }
15079
15080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
15081 where
15082 V: serde::de::MapAccess<'de>,
15083 {
15084 let mut change_logs__ = None;
15085 while let Some(k) = map_.next_key()? {
15086 match k {
15087 GeneratedField::ChangeLogs => {
15088 if change_logs__.is_some() {
15089 return Err(serde::de::Error::duplicate_field("changeLogs"));
15090 }
15091 change_logs__ = Some(map_.next_value()?);
15092 }
15093 }
15094 }
15095 Ok(TableChangeLog {
15096 change_logs: change_logs__.unwrap_or_default(),
15097 })
15098 }
15099 }
15100 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
15101 }
15102}
15103impl serde::Serialize for TableOption {
15104 #[allow(deprecated)]
15105 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15106 where
15107 S: serde::Serializer,
15108 {
15109 use serde::ser::SerializeStruct;
15110 let mut len = 0;
15111 if self.retention_seconds.is_some() {
15112 len += 1;
15113 }
15114 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
15115 if let Some(v) = self.retention_seconds.as_ref() {
15116 struct_ser.serialize_field("retentionSeconds", v)?;
15117 }
15118 struct_ser.end()
15119 }
15120}
15121impl<'de> serde::Deserialize<'de> for TableOption {
15122 #[allow(deprecated)]
15123 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15124 where
15125 D: serde::Deserializer<'de>,
15126 {
15127 const FIELDS: &[&str] = &[
15128 "retention_seconds",
15129 "retentionSeconds",
15130 ];
15131
15132 #[allow(clippy::enum_variant_names)]
15133 enum GeneratedField {
15134 RetentionSeconds,
15135 }
15136 impl<'de> serde::Deserialize<'de> for GeneratedField {
15137 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15138 where
15139 D: serde::Deserializer<'de>,
15140 {
15141 struct GeneratedVisitor;
15142
15143 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15144 type Value = GeneratedField;
15145
15146 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15147 write!(formatter, "expected one of: {:?}", &FIELDS)
15148 }
15149
15150 #[allow(unused_variables)]
15151 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15152 where
15153 E: serde::de::Error,
15154 {
15155 match value {
15156 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
15157 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15158 }
15159 }
15160 }
15161 deserializer.deserialize_identifier(GeneratedVisitor)
15162 }
15163 }
15164 struct GeneratedVisitor;
15165 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15166 type Value = TableOption;
15167
15168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15169 formatter.write_str("struct hummock.TableOption")
15170 }
15171
15172 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
15173 where
15174 V: serde::de::MapAccess<'de>,
15175 {
15176 let mut retention_seconds__ = None;
15177 while let Some(k) = map_.next_key()? {
15178 match k {
15179 GeneratedField::RetentionSeconds => {
15180 if retention_seconds__.is_some() {
15181 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
15182 }
15183 retention_seconds__ =
15184 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15185 ;
15186 }
15187 }
15188 }
15189 Ok(TableOption {
15190 retention_seconds: retention_seconds__,
15191 })
15192 }
15193 }
15194 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
15195 }
15196}
15197impl serde::Serialize for TableSchema {
15198 #[allow(deprecated)]
15199 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15200 where
15201 S: serde::Serializer,
15202 {
15203 use serde::ser::SerializeStruct;
15204 let mut len = 0;
15205 if !self.column_ids.is_empty() {
15206 len += 1;
15207 }
15208 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
15209 if !self.column_ids.is_empty() {
15210 struct_ser.serialize_field("columnIds", &self.column_ids)?;
15211 }
15212 struct_ser.end()
15213 }
15214}
15215impl<'de> serde::Deserialize<'de> for TableSchema {
15216 #[allow(deprecated)]
15217 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15218 where
15219 D: serde::Deserializer<'de>,
15220 {
15221 const FIELDS: &[&str] = &[
15222 "column_ids",
15223 "columnIds",
15224 ];
15225
15226 #[allow(clippy::enum_variant_names)]
15227 enum GeneratedField {
15228 ColumnIds,
15229 }
15230 impl<'de> serde::Deserialize<'de> for GeneratedField {
15231 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15232 where
15233 D: serde::Deserializer<'de>,
15234 {
15235 struct GeneratedVisitor;
15236
15237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15238 type Value = GeneratedField;
15239
15240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15241 write!(formatter, "expected one of: {:?}", &FIELDS)
15242 }
15243
15244 #[allow(unused_variables)]
15245 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15246 where
15247 E: serde::de::Error,
15248 {
15249 match value {
15250 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
15251 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15252 }
15253 }
15254 }
15255 deserializer.deserialize_identifier(GeneratedVisitor)
15256 }
15257 }
15258 struct GeneratedVisitor;
15259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15260 type Value = TableSchema;
15261
15262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15263 formatter.write_str("struct hummock.TableSchema")
15264 }
15265
15266 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
15267 where
15268 V: serde::de::MapAccess<'de>,
15269 {
15270 let mut column_ids__ = None;
15271 while let Some(k) = map_.next_key()? {
15272 match k {
15273 GeneratedField::ColumnIds => {
15274 if column_ids__.is_some() {
15275 return Err(serde::de::Error::duplicate_field("columnIds"));
15276 }
15277 column_ids__ =
15278 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15279 .into_iter().map(|x| x.0).collect())
15280 ;
15281 }
15282 }
15283 }
15284 Ok(TableSchema {
15285 column_ids: column_ids__.unwrap_or_default(),
15286 })
15287 }
15288 }
15289 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
15290 }
15291}
15292impl serde::Serialize for TableStats {
15293 #[allow(deprecated)]
15294 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15295 where
15296 S: serde::Serializer,
15297 {
15298 use serde::ser::SerializeStruct;
15299 let mut len = 0;
15300 if self.total_key_size != 0 {
15301 len += 1;
15302 }
15303 if self.total_value_size != 0 {
15304 len += 1;
15305 }
15306 if self.total_key_count != 0 {
15307 len += 1;
15308 }
15309 if self.total_compressed_size != 0 {
15310 len += 1;
15311 }
15312 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
15313 if self.total_key_size != 0 {
15314 #[allow(clippy::needless_borrow)]
15315 #[allow(clippy::needless_borrows_for_generic_args)]
15316 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
15317 }
15318 if self.total_value_size != 0 {
15319 #[allow(clippy::needless_borrow)]
15320 #[allow(clippy::needless_borrows_for_generic_args)]
15321 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
15322 }
15323 if self.total_key_count != 0 {
15324 #[allow(clippy::needless_borrow)]
15325 #[allow(clippy::needless_borrows_for_generic_args)]
15326 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
15327 }
15328 if self.total_compressed_size != 0 {
15329 #[allow(clippy::needless_borrow)]
15330 #[allow(clippy::needless_borrows_for_generic_args)]
15331 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
15332 }
15333 struct_ser.end()
15334 }
15335}
15336impl<'de> serde::Deserialize<'de> for TableStats {
15337 #[allow(deprecated)]
15338 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15339 where
15340 D: serde::Deserializer<'de>,
15341 {
15342 const FIELDS: &[&str] = &[
15343 "total_key_size",
15344 "totalKeySize",
15345 "total_value_size",
15346 "totalValueSize",
15347 "total_key_count",
15348 "totalKeyCount",
15349 "total_compressed_size",
15350 "totalCompressedSize",
15351 ];
15352
15353 #[allow(clippy::enum_variant_names)]
15354 enum GeneratedField {
15355 TotalKeySize,
15356 TotalValueSize,
15357 TotalKeyCount,
15358 TotalCompressedSize,
15359 }
15360 impl<'de> serde::Deserialize<'de> for GeneratedField {
15361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15362 where
15363 D: serde::Deserializer<'de>,
15364 {
15365 struct GeneratedVisitor;
15366
15367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15368 type Value = GeneratedField;
15369
15370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15371 write!(formatter, "expected one of: {:?}", &FIELDS)
15372 }
15373
15374 #[allow(unused_variables)]
15375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15376 where
15377 E: serde::de::Error,
15378 {
15379 match value {
15380 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
15381 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
15382 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
15383 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
15384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15385 }
15386 }
15387 }
15388 deserializer.deserialize_identifier(GeneratedVisitor)
15389 }
15390 }
15391 struct GeneratedVisitor;
15392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15393 type Value = TableStats;
15394
15395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15396 formatter.write_str("struct hummock.TableStats")
15397 }
15398
15399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
15400 where
15401 V: serde::de::MapAccess<'de>,
15402 {
15403 let mut total_key_size__ = None;
15404 let mut total_value_size__ = None;
15405 let mut total_key_count__ = None;
15406 let mut total_compressed_size__ = None;
15407 while let Some(k) = map_.next_key()? {
15408 match k {
15409 GeneratedField::TotalKeySize => {
15410 if total_key_size__.is_some() {
15411 return Err(serde::de::Error::duplicate_field("totalKeySize"));
15412 }
15413 total_key_size__ =
15414 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15415 ;
15416 }
15417 GeneratedField::TotalValueSize => {
15418 if total_value_size__.is_some() {
15419 return Err(serde::de::Error::duplicate_field("totalValueSize"));
15420 }
15421 total_value_size__ =
15422 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15423 ;
15424 }
15425 GeneratedField::TotalKeyCount => {
15426 if total_key_count__.is_some() {
15427 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
15428 }
15429 total_key_count__ =
15430 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15431 ;
15432 }
15433 GeneratedField::TotalCompressedSize => {
15434 if total_compressed_size__.is_some() {
15435 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
15436 }
15437 total_compressed_size__ =
15438 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15439 ;
15440 }
15441 }
15442 }
15443 Ok(TableStats {
15444 total_key_size: total_key_size__.unwrap_or_default(),
15445 total_value_size: total_value_size__.unwrap_or_default(),
15446 total_key_count: total_key_count__.unwrap_or_default(),
15447 total_compressed_size: total_compressed_size__.unwrap_or_default(),
15448 })
15449 }
15450 }
15451 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
15452 }
15453}
15454impl serde::Serialize for TableWatermarks {
15455 #[allow(deprecated)]
15456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15457 where
15458 S: serde::Serializer,
15459 {
15460 use serde::ser::SerializeStruct;
15461 let mut len = 0;
15462 if !self.epoch_watermarks.is_empty() {
15463 len += 1;
15464 }
15465 if self.is_ascending {
15466 len += 1;
15467 }
15468 if self.is_non_pk_prefix {
15469 len += 1;
15470 }
15471 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
15472 if !self.epoch_watermarks.is_empty() {
15473 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
15474 }
15475 if self.is_ascending {
15476 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
15477 }
15478 if self.is_non_pk_prefix {
15479 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
15480 }
15481 struct_ser.end()
15482 }
15483}
15484impl<'de> serde::Deserialize<'de> for TableWatermarks {
15485 #[allow(deprecated)]
15486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15487 where
15488 D: serde::Deserializer<'de>,
15489 {
15490 const FIELDS: &[&str] = &[
15491 "epoch_watermarks",
15492 "epochWatermarks",
15493 "is_ascending",
15494 "isAscending",
15495 "is_non_pk_prefix",
15496 "isNonPkPrefix",
15497 ];
15498
15499 #[allow(clippy::enum_variant_names)]
15500 enum GeneratedField {
15501 EpochWatermarks,
15502 IsAscending,
15503 IsNonPkPrefix,
15504 }
15505 impl<'de> serde::Deserialize<'de> for GeneratedField {
15506 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15507 where
15508 D: serde::Deserializer<'de>,
15509 {
15510 struct GeneratedVisitor;
15511
15512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15513 type Value = GeneratedField;
15514
15515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15516 write!(formatter, "expected one of: {:?}", &FIELDS)
15517 }
15518
15519 #[allow(unused_variables)]
15520 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15521 where
15522 E: serde::de::Error,
15523 {
15524 match value {
15525 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
15526 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
15527 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
15528 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15529 }
15530 }
15531 }
15532 deserializer.deserialize_identifier(GeneratedVisitor)
15533 }
15534 }
15535 struct GeneratedVisitor;
15536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15537 type Value = TableWatermarks;
15538
15539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15540 formatter.write_str("struct hummock.TableWatermarks")
15541 }
15542
15543 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
15544 where
15545 V: serde::de::MapAccess<'de>,
15546 {
15547 let mut epoch_watermarks__ = None;
15548 let mut is_ascending__ = None;
15549 let mut is_non_pk_prefix__ = None;
15550 while let Some(k) = map_.next_key()? {
15551 match k {
15552 GeneratedField::EpochWatermarks => {
15553 if epoch_watermarks__.is_some() {
15554 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
15555 }
15556 epoch_watermarks__ = Some(map_.next_value()?);
15557 }
15558 GeneratedField::IsAscending => {
15559 if is_ascending__.is_some() {
15560 return Err(serde::de::Error::duplicate_field("isAscending"));
15561 }
15562 is_ascending__ = Some(map_.next_value()?);
15563 }
15564 GeneratedField::IsNonPkPrefix => {
15565 if is_non_pk_prefix__.is_some() {
15566 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
15567 }
15568 is_non_pk_prefix__ = Some(map_.next_value()?);
15569 }
15570 }
15571 }
15572 Ok(TableWatermarks {
15573 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
15574 is_ascending: is_ascending__.unwrap_or_default(),
15575 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
15576 })
15577 }
15578 }
15579 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
15580 }
15581}
15582impl serde::Serialize for table_watermarks::EpochNewWatermarks {
15583 #[allow(deprecated)]
15584 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15585 where
15586 S: serde::Serializer,
15587 {
15588 use serde::ser::SerializeStruct;
15589 let mut len = 0;
15590 if !self.watermarks.is_empty() {
15591 len += 1;
15592 }
15593 if self.epoch != 0 {
15594 len += 1;
15595 }
15596 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
15597 if !self.watermarks.is_empty() {
15598 struct_ser.serialize_field("watermarks", &self.watermarks)?;
15599 }
15600 if self.epoch != 0 {
15601 #[allow(clippy::needless_borrow)]
15602 #[allow(clippy::needless_borrows_for_generic_args)]
15603 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
15604 }
15605 struct_ser.end()
15606 }
15607}
15608impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
15609 #[allow(deprecated)]
15610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15611 where
15612 D: serde::Deserializer<'de>,
15613 {
15614 const FIELDS: &[&str] = &[
15615 "watermarks",
15616 "epoch",
15617 ];
15618
15619 #[allow(clippy::enum_variant_names)]
15620 enum GeneratedField {
15621 Watermarks,
15622 Epoch,
15623 }
15624 impl<'de> serde::Deserialize<'de> for GeneratedField {
15625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15626 where
15627 D: serde::Deserializer<'de>,
15628 {
15629 struct GeneratedVisitor;
15630
15631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15632 type Value = GeneratedField;
15633
15634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15635 write!(formatter, "expected one of: {:?}", &FIELDS)
15636 }
15637
15638 #[allow(unused_variables)]
15639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15640 where
15641 E: serde::de::Error,
15642 {
15643 match value {
15644 "watermarks" => Ok(GeneratedField::Watermarks),
15645 "epoch" => Ok(GeneratedField::Epoch),
15646 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15647 }
15648 }
15649 }
15650 deserializer.deserialize_identifier(GeneratedVisitor)
15651 }
15652 }
15653 struct GeneratedVisitor;
15654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15655 type Value = table_watermarks::EpochNewWatermarks;
15656
15657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15658 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
15659 }
15660
15661 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
15662 where
15663 V: serde::de::MapAccess<'de>,
15664 {
15665 let mut watermarks__ = None;
15666 let mut epoch__ = None;
15667 while let Some(k) = map_.next_key()? {
15668 match k {
15669 GeneratedField::Watermarks => {
15670 if watermarks__.is_some() {
15671 return Err(serde::de::Error::duplicate_field("watermarks"));
15672 }
15673 watermarks__ = Some(map_.next_value()?);
15674 }
15675 GeneratedField::Epoch => {
15676 if epoch__.is_some() {
15677 return Err(serde::de::Error::duplicate_field("epoch"));
15678 }
15679 epoch__ =
15680 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15681 ;
15682 }
15683 }
15684 }
15685 Ok(table_watermarks::EpochNewWatermarks {
15686 watermarks: watermarks__.unwrap_or_default(),
15687 epoch: epoch__.unwrap_or_default(),
15688 })
15689 }
15690 }
15691 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
15692 }
15693}
15694impl serde::Serialize for TriggerCompactionDeterministicRequest {
15695 #[allow(deprecated)]
15696 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15697 where
15698 S: serde::Serializer,
15699 {
15700 use serde::ser::SerializeStruct;
15701 let mut len = 0;
15702 if self.version_id != 0 {
15703 len += 1;
15704 }
15705 if !self.compaction_groups.is_empty() {
15706 len += 1;
15707 }
15708 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
15709 if self.version_id != 0 {
15710 #[allow(clippy::needless_borrow)]
15711 #[allow(clippy::needless_borrows_for_generic_args)]
15712 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
15713 }
15714 if !self.compaction_groups.is_empty() {
15715 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15716 }
15717 struct_ser.end()
15718 }
15719}
15720impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
15721 #[allow(deprecated)]
15722 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15723 where
15724 D: serde::Deserializer<'de>,
15725 {
15726 const FIELDS: &[&str] = &[
15727 "version_id",
15728 "versionId",
15729 "compaction_groups",
15730 "compactionGroups",
15731 ];
15732
15733 #[allow(clippy::enum_variant_names)]
15734 enum GeneratedField {
15735 VersionId,
15736 CompactionGroups,
15737 }
15738 impl<'de> serde::Deserialize<'de> for GeneratedField {
15739 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15740 where
15741 D: serde::Deserializer<'de>,
15742 {
15743 struct GeneratedVisitor;
15744
15745 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15746 type Value = GeneratedField;
15747
15748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15749 write!(formatter, "expected one of: {:?}", &FIELDS)
15750 }
15751
15752 #[allow(unused_variables)]
15753 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15754 where
15755 E: serde::de::Error,
15756 {
15757 match value {
15758 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
15759 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
15760 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15761 }
15762 }
15763 }
15764 deserializer.deserialize_identifier(GeneratedVisitor)
15765 }
15766 }
15767 struct GeneratedVisitor;
15768 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15769 type Value = TriggerCompactionDeterministicRequest;
15770
15771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15772 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
15773 }
15774
15775 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
15776 where
15777 V: serde::de::MapAccess<'de>,
15778 {
15779 let mut version_id__ = None;
15780 let mut compaction_groups__ = None;
15781 while let Some(k) = map_.next_key()? {
15782 match k {
15783 GeneratedField::VersionId => {
15784 if version_id__.is_some() {
15785 return Err(serde::de::Error::duplicate_field("versionId"));
15786 }
15787 version_id__ =
15788 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15789 ;
15790 }
15791 GeneratedField::CompactionGroups => {
15792 if compaction_groups__.is_some() {
15793 return Err(serde::de::Error::duplicate_field("compactionGroups"));
15794 }
15795 compaction_groups__ =
15796 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15797 .into_iter().map(|x| x.0).collect())
15798 ;
15799 }
15800 }
15801 }
15802 Ok(TriggerCompactionDeterministicRequest {
15803 version_id: version_id__.unwrap_or_default(),
15804 compaction_groups: compaction_groups__.unwrap_or_default(),
15805 })
15806 }
15807 }
15808 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
15809 }
15810}
15811impl serde::Serialize for TriggerCompactionDeterministicResponse {
15812 #[allow(deprecated)]
15813 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15814 where
15815 S: serde::Serializer,
15816 {
15817 use serde::ser::SerializeStruct;
15818 let len = 0;
15819 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
15820 struct_ser.end()
15821 }
15822}
15823impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
15824 #[allow(deprecated)]
15825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15826 where
15827 D: serde::Deserializer<'de>,
15828 {
15829 const FIELDS: &[&str] = &[
15830 ];
15831
15832 #[allow(clippy::enum_variant_names)]
15833 enum GeneratedField {
15834 }
15835 impl<'de> serde::Deserialize<'de> for GeneratedField {
15836 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15837 where
15838 D: serde::Deserializer<'de>,
15839 {
15840 struct GeneratedVisitor;
15841
15842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15843 type Value = GeneratedField;
15844
15845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15846 write!(formatter, "expected one of: {:?}", &FIELDS)
15847 }
15848
15849 #[allow(unused_variables)]
15850 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15851 where
15852 E: serde::de::Error,
15853 {
15854 Err(serde::de::Error::unknown_field(value, FIELDS))
15855 }
15856 }
15857 deserializer.deserialize_identifier(GeneratedVisitor)
15858 }
15859 }
15860 struct GeneratedVisitor;
15861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15862 type Value = TriggerCompactionDeterministicResponse;
15863
15864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15865 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
15866 }
15867
15868 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
15869 where
15870 V: serde::de::MapAccess<'de>,
15871 {
15872 while map_.next_key::<GeneratedField>()?.is_some() {
15873 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15874 }
15875 Ok(TriggerCompactionDeterministicResponse {
15876 })
15877 }
15878 }
15879 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
15880 }
15881}
15882impl serde::Serialize for TriggerFullGcRequest {
15883 #[allow(deprecated)]
15884 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15885 where
15886 S: serde::Serializer,
15887 {
15888 use serde::ser::SerializeStruct;
15889 let mut len = 0;
15890 if self.sst_retention_time_sec != 0 {
15891 len += 1;
15892 }
15893 if self.prefix.is_some() {
15894 len += 1;
15895 }
15896 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
15897 if self.sst_retention_time_sec != 0 {
15898 #[allow(clippy::needless_borrow)]
15899 #[allow(clippy::needless_borrows_for_generic_args)]
15900 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
15901 }
15902 if let Some(v) = self.prefix.as_ref() {
15903 struct_ser.serialize_field("prefix", v)?;
15904 }
15905 struct_ser.end()
15906 }
15907}
15908impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
15909 #[allow(deprecated)]
15910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15911 where
15912 D: serde::Deserializer<'de>,
15913 {
15914 const FIELDS: &[&str] = &[
15915 "sst_retention_time_sec",
15916 "sstRetentionTimeSec",
15917 "prefix",
15918 ];
15919
15920 #[allow(clippy::enum_variant_names)]
15921 enum GeneratedField {
15922 SstRetentionTimeSec,
15923 Prefix,
15924 }
15925 impl<'de> serde::Deserialize<'de> for GeneratedField {
15926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15927 where
15928 D: serde::Deserializer<'de>,
15929 {
15930 struct GeneratedVisitor;
15931
15932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15933 type Value = GeneratedField;
15934
15935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15936 write!(formatter, "expected one of: {:?}", &FIELDS)
15937 }
15938
15939 #[allow(unused_variables)]
15940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15941 where
15942 E: serde::de::Error,
15943 {
15944 match value {
15945 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
15946 "prefix" => Ok(GeneratedField::Prefix),
15947 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15948 }
15949 }
15950 }
15951 deserializer.deserialize_identifier(GeneratedVisitor)
15952 }
15953 }
15954 struct GeneratedVisitor;
15955 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15956 type Value = TriggerFullGcRequest;
15957
15958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15959 formatter.write_str("struct hummock.TriggerFullGCRequest")
15960 }
15961
15962 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
15963 where
15964 V: serde::de::MapAccess<'de>,
15965 {
15966 let mut sst_retention_time_sec__ = None;
15967 let mut prefix__ = None;
15968 while let Some(k) = map_.next_key()? {
15969 match k {
15970 GeneratedField::SstRetentionTimeSec => {
15971 if sst_retention_time_sec__.is_some() {
15972 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
15973 }
15974 sst_retention_time_sec__ =
15975 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15976 ;
15977 }
15978 GeneratedField::Prefix => {
15979 if prefix__.is_some() {
15980 return Err(serde::de::Error::duplicate_field("prefix"));
15981 }
15982 prefix__ = map_.next_value()?;
15983 }
15984 }
15985 }
15986 Ok(TriggerFullGcRequest {
15987 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
15988 prefix: prefix__,
15989 })
15990 }
15991 }
15992 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
15993 }
15994}
15995impl serde::Serialize for TriggerFullGcResponse {
15996 #[allow(deprecated)]
15997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15998 where
15999 S: serde::Serializer,
16000 {
16001 use serde::ser::SerializeStruct;
16002 let mut len = 0;
16003 if self.status.is_some() {
16004 len += 1;
16005 }
16006 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
16007 if let Some(v) = self.status.as_ref() {
16008 struct_ser.serialize_field("status", v)?;
16009 }
16010 struct_ser.end()
16011 }
16012}
16013impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
16014 #[allow(deprecated)]
16015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16016 where
16017 D: serde::Deserializer<'de>,
16018 {
16019 const FIELDS: &[&str] = &[
16020 "status",
16021 ];
16022
16023 #[allow(clippy::enum_variant_names)]
16024 enum GeneratedField {
16025 Status,
16026 }
16027 impl<'de> serde::Deserialize<'de> for GeneratedField {
16028 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16029 where
16030 D: serde::Deserializer<'de>,
16031 {
16032 struct GeneratedVisitor;
16033
16034 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16035 type Value = GeneratedField;
16036
16037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16038 write!(formatter, "expected one of: {:?}", &FIELDS)
16039 }
16040
16041 #[allow(unused_variables)]
16042 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16043 where
16044 E: serde::de::Error,
16045 {
16046 match value {
16047 "status" => Ok(GeneratedField::Status),
16048 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16049 }
16050 }
16051 }
16052 deserializer.deserialize_identifier(GeneratedVisitor)
16053 }
16054 }
16055 struct GeneratedVisitor;
16056 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16057 type Value = TriggerFullGcResponse;
16058
16059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16060 formatter.write_str("struct hummock.TriggerFullGCResponse")
16061 }
16062
16063 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
16064 where
16065 V: serde::de::MapAccess<'de>,
16066 {
16067 let mut status__ = None;
16068 while let Some(k) = map_.next_key()? {
16069 match k {
16070 GeneratedField::Status => {
16071 if status__.is_some() {
16072 return Err(serde::de::Error::duplicate_field("status"));
16073 }
16074 status__ = map_.next_value()?;
16075 }
16076 }
16077 }
16078 Ok(TriggerFullGcResponse {
16079 status: status__,
16080 })
16081 }
16082 }
16083 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
16084 }
16085}
16086impl serde::Serialize for TriggerManualCompactionRequest {
16087 #[allow(deprecated)]
16088 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16089 where
16090 S: serde::Serializer,
16091 {
16092 use serde::ser::SerializeStruct;
16093 let mut len = 0;
16094 if self.compaction_group_id != 0 {
16095 len += 1;
16096 }
16097 if self.key_range.is_some() {
16098 len += 1;
16099 }
16100 if self.table_id != 0 {
16101 len += 1;
16102 }
16103 if self.level != 0 {
16104 len += 1;
16105 }
16106 if !self.sst_ids.is_empty() {
16107 len += 1;
16108 }
16109 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
16110 if self.compaction_group_id != 0 {
16111 #[allow(clippy::needless_borrow)]
16112 #[allow(clippy::needless_borrows_for_generic_args)]
16113 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
16114 }
16115 if let Some(v) = self.key_range.as_ref() {
16116 struct_ser.serialize_field("keyRange", v)?;
16117 }
16118 if self.table_id != 0 {
16119 struct_ser.serialize_field("tableId", &self.table_id)?;
16120 }
16121 if self.level != 0 {
16122 struct_ser.serialize_field("level", &self.level)?;
16123 }
16124 if !self.sst_ids.is_empty() {
16125 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16126 }
16127 struct_ser.end()
16128 }
16129}
16130impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
16131 #[allow(deprecated)]
16132 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16133 where
16134 D: serde::Deserializer<'de>,
16135 {
16136 const FIELDS: &[&str] = &[
16137 "compaction_group_id",
16138 "compactionGroupId",
16139 "key_range",
16140 "keyRange",
16141 "table_id",
16142 "tableId",
16143 "level",
16144 "sst_ids",
16145 "sstIds",
16146 ];
16147
16148 #[allow(clippy::enum_variant_names)]
16149 enum GeneratedField {
16150 CompactionGroupId,
16151 KeyRange,
16152 TableId,
16153 Level,
16154 SstIds,
16155 }
16156 impl<'de> serde::Deserialize<'de> for GeneratedField {
16157 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16158 where
16159 D: serde::Deserializer<'de>,
16160 {
16161 struct GeneratedVisitor;
16162
16163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16164 type Value = GeneratedField;
16165
16166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16167 write!(formatter, "expected one of: {:?}", &FIELDS)
16168 }
16169
16170 #[allow(unused_variables)]
16171 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16172 where
16173 E: serde::de::Error,
16174 {
16175 match value {
16176 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
16177 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
16178 "tableId" | "table_id" => Ok(GeneratedField::TableId),
16179 "level" => Ok(GeneratedField::Level),
16180 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
16181 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16182 }
16183 }
16184 }
16185 deserializer.deserialize_identifier(GeneratedVisitor)
16186 }
16187 }
16188 struct GeneratedVisitor;
16189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16190 type Value = TriggerManualCompactionRequest;
16191
16192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16193 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
16194 }
16195
16196 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
16197 where
16198 V: serde::de::MapAccess<'de>,
16199 {
16200 let mut compaction_group_id__ = None;
16201 let mut key_range__ = None;
16202 let mut table_id__ = None;
16203 let mut level__ = None;
16204 let mut sst_ids__ = None;
16205 while let Some(k) = map_.next_key()? {
16206 match k {
16207 GeneratedField::CompactionGroupId => {
16208 if compaction_group_id__.is_some() {
16209 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
16210 }
16211 compaction_group_id__ =
16212 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16213 ;
16214 }
16215 GeneratedField::KeyRange => {
16216 if key_range__.is_some() {
16217 return Err(serde::de::Error::duplicate_field("keyRange"));
16218 }
16219 key_range__ = map_.next_value()?;
16220 }
16221 GeneratedField::TableId => {
16222 if table_id__.is_some() {
16223 return Err(serde::de::Error::duplicate_field("tableId"));
16224 }
16225 table_id__ =
16226 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16227 ;
16228 }
16229 GeneratedField::Level => {
16230 if level__.is_some() {
16231 return Err(serde::de::Error::duplicate_field("level"));
16232 }
16233 level__ =
16234 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16235 ;
16236 }
16237 GeneratedField::SstIds => {
16238 if sst_ids__.is_some() {
16239 return Err(serde::de::Error::duplicate_field("sstIds"));
16240 }
16241 sst_ids__ =
16242 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16243 .into_iter().map(|x| x.0).collect())
16244 ;
16245 }
16246 }
16247 }
16248 Ok(TriggerManualCompactionRequest {
16249 compaction_group_id: compaction_group_id__.unwrap_or_default(),
16250 key_range: key_range__,
16251 table_id: table_id__.unwrap_or_default(),
16252 level: level__.unwrap_or_default(),
16253 sst_ids: sst_ids__.unwrap_or_default(),
16254 })
16255 }
16256 }
16257 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
16258 }
16259}
16260impl serde::Serialize for TriggerManualCompactionResponse {
16261 #[allow(deprecated)]
16262 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16263 where
16264 S: serde::Serializer,
16265 {
16266 use serde::ser::SerializeStruct;
16267 let mut len = 0;
16268 if self.status.is_some() {
16269 len += 1;
16270 }
16271 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
16272 if let Some(v) = self.status.as_ref() {
16273 struct_ser.serialize_field("status", v)?;
16274 }
16275 struct_ser.end()
16276 }
16277}
16278impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
16279 #[allow(deprecated)]
16280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16281 where
16282 D: serde::Deserializer<'de>,
16283 {
16284 const FIELDS: &[&str] = &[
16285 "status",
16286 ];
16287
16288 #[allow(clippy::enum_variant_names)]
16289 enum GeneratedField {
16290 Status,
16291 }
16292 impl<'de> serde::Deserialize<'de> for GeneratedField {
16293 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16294 where
16295 D: serde::Deserializer<'de>,
16296 {
16297 struct GeneratedVisitor;
16298
16299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16300 type Value = GeneratedField;
16301
16302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16303 write!(formatter, "expected one of: {:?}", &FIELDS)
16304 }
16305
16306 #[allow(unused_variables)]
16307 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16308 where
16309 E: serde::de::Error,
16310 {
16311 match value {
16312 "status" => Ok(GeneratedField::Status),
16313 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16314 }
16315 }
16316 }
16317 deserializer.deserialize_identifier(GeneratedVisitor)
16318 }
16319 }
16320 struct GeneratedVisitor;
16321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16322 type Value = TriggerManualCompactionResponse;
16323
16324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16325 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
16326 }
16327
16328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
16329 where
16330 V: serde::de::MapAccess<'de>,
16331 {
16332 let mut status__ = None;
16333 while let Some(k) = map_.next_key()? {
16334 match k {
16335 GeneratedField::Status => {
16336 if status__.is_some() {
16337 return Err(serde::de::Error::duplicate_field("status"));
16338 }
16339 status__ = map_.next_value()?;
16340 }
16341 }
16342 }
16343 Ok(TriggerManualCompactionResponse {
16344 status: status__,
16345 })
16346 }
16347 }
16348 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
16349 }
16350}
16351impl serde::Serialize for TruncateTables {
16352 #[allow(deprecated)]
16353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16354 where
16355 S: serde::Serializer,
16356 {
16357 use serde::ser::SerializeStruct;
16358 let mut len = 0;
16359 if !self.table_ids.is_empty() {
16360 len += 1;
16361 }
16362 let mut struct_ser = serializer.serialize_struct("hummock.TruncateTables", len)?;
16363 if !self.table_ids.is_empty() {
16364 struct_ser.serialize_field("tableIds", &self.table_ids)?;
16365 }
16366 struct_ser.end()
16367 }
16368}
16369impl<'de> serde::Deserialize<'de> for TruncateTables {
16370 #[allow(deprecated)]
16371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16372 where
16373 D: serde::Deserializer<'de>,
16374 {
16375 const FIELDS: &[&str] = &[
16376 "table_ids",
16377 "tableIds",
16378 ];
16379
16380 #[allow(clippy::enum_variant_names)]
16381 enum GeneratedField {
16382 TableIds,
16383 }
16384 impl<'de> serde::Deserialize<'de> for GeneratedField {
16385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16386 where
16387 D: serde::Deserializer<'de>,
16388 {
16389 struct GeneratedVisitor;
16390
16391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16392 type Value = GeneratedField;
16393
16394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16395 write!(formatter, "expected one of: {:?}", &FIELDS)
16396 }
16397
16398 #[allow(unused_variables)]
16399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16400 where
16401 E: serde::de::Error,
16402 {
16403 match value {
16404 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
16405 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16406 }
16407 }
16408 }
16409 deserializer.deserialize_identifier(GeneratedVisitor)
16410 }
16411 }
16412 struct GeneratedVisitor;
16413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16414 type Value = TruncateTables;
16415
16416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16417 formatter.write_str("struct hummock.TruncateTables")
16418 }
16419
16420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TruncateTables, V::Error>
16421 where
16422 V: serde::de::MapAccess<'de>,
16423 {
16424 let mut table_ids__ = None;
16425 while let Some(k) = map_.next_key()? {
16426 match k {
16427 GeneratedField::TableIds => {
16428 if table_ids__.is_some() {
16429 return Err(serde::de::Error::duplicate_field("tableIds"));
16430 }
16431 table_ids__ =
16432 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16433 .into_iter().map(|x| x.0).collect())
16434 ;
16435 }
16436 }
16437 }
16438 Ok(TruncateTables {
16439 table_ids: table_ids__.unwrap_or_default(),
16440 })
16441 }
16442 }
16443 deserializer.deserialize_struct("hummock.TruncateTables", FIELDS, GeneratedVisitor)
16444 }
16445}
16446impl serde::Serialize for UnpinVersionBeforeRequest {
16447 #[allow(deprecated)]
16448 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16449 where
16450 S: serde::Serializer,
16451 {
16452 use serde::ser::SerializeStruct;
16453 let mut len = 0;
16454 if self.context_id != 0 {
16455 len += 1;
16456 }
16457 if self.unpin_version_before != 0 {
16458 len += 1;
16459 }
16460 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
16461 if self.context_id != 0 {
16462 struct_ser.serialize_field("contextId", &self.context_id)?;
16463 }
16464 if self.unpin_version_before != 0 {
16465 #[allow(clippy::needless_borrow)]
16466 #[allow(clippy::needless_borrows_for_generic_args)]
16467 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
16468 }
16469 struct_ser.end()
16470 }
16471}
16472impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
16473 #[allow(deprecated)]
16474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16475 where
16476 D: serde::Deserializer<'de>,
16477 {
16478 const FIELDS: &[&str] = &[
16479 "context_id",
16480 "contextId",
16481 "unpin_version_before",
16482 "unpinVersionBefore",
16483 ];
16484
16485 #[allow(clippy::enum_variant_names)]
16486 enum GeneratedField {
16487 ContextId,
16488 UnpinVersionBefore,
16489 }
16490 impl<'de> serde::Deserialize<'de> for GeneratedField {
16491 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16492 where
16493 D: serde::Deserializer<'de>,
16494 {
16495 struct GeneratedVisitor;
16496
16497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16498 type Value = GeneratedField;
16499
16500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16501 write!(formatter, "expected one of: {:?}", &FIELDS)
16502 }
16503
16504 #[allow(unused_variables)]
16505 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16506 where
16507 E: serde::de::Error,
16508 {
16509 match value {
16510 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
16511 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
16512 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16513 }
16514 }
16515 }
16516 deserializer.deserialize_identifier(GeneratedVisitor)
16517 }
16518 }
16519 struct GeneratedVisitor;
16520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16521 type Value = UnpinVersionBeforeRequest;
16522
16523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16524 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
16525 }
16526
16527 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
16528 where
16529 V: serde::de::MapAccess<'de>,
16530 {
16531 let mut context_id__ = None;
16532 let mut unpin_version_before__ = None;
16533 while let Some(k) = map_.next_key()? {
16534 match k {
16535 GeneratedField::ContextId => {
16536 if context_id__.is_some() {
16537 return Err(serde::de::Error::duplicate_field("contextId"));
16538 }
16539 context_id__ =
16540 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16541 ;
16542 }
16543 GeneratedField::UnpinVersionBefore => {
16544 if unpin_version_before__.is_some() {
16545 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
16546 }
16547 unpin_version_before__ =
16548 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16549 ;
16550 }
16551 }
16552 }
16553 Ok(UnpinVersionBeforeRequest {
16554 context_id: context_id__.unwrap_or_default(),
16555 unpin_version_before: unpin_version_before__.unwrap_or_default(),
16556 })
16557 }
16558 }
16559 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
16560 }
16561}
16562impl serde::Serialize for UnpinVersionBeforeResponse {
16563 #[allow(deprecated)]
16564 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16565 where
16566 S: serde::Serializer,
16567 {
16568 use serde::ser::SerializeStruct;
16569 let mut len = 0;
16570 if self.status.is_some() {
16571 len += 1;
16572 }
16573 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
16574 if let Some(v) = self.status.as_ref() {
16575 struct_ser.serialize_field("status", v)?;
16576 }
16577 struct_ser.end()
16578 }
16579}
16580impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
16581 #[allow(deprecated)]
16582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16583 where
16584 D: serde::Deserializer<'de>,
16585 {
16586 const FIELDS: &[&str] = &[
16587 "status",
16588 ];
16589
16590 #[allow(clippy::enum_variant_names)]
16591 enum GeneratedField {
16592 Status,
16593 }
16594 impl<'de> serde::Deserialize<'de> for GeneratedField {
16595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16596 where
16597 D: serde::Deserializer<'de>,
16598 {
16599 struct GeneratedVisitor;
16600
16601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16602 type Value = GeneratedField;
16603
16604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16605 write!(formatter, "expected one of: {:?}", &FIELDS)
16606 }
16607
16608 #[allow(unused_variables)]
16609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16610 where
16611 E: serde::de::Error,
16612 {
16613 match value {
16614 "status" => Ok(GeneratedField::Status),
16615 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16616 }
16617 }
16618 }
16619 deserializer.deserialize_identifier(GeneratedVisitor)
16620 }
16621 }
16622 struct GeneratedVisitor;
16623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16624 type Value = UnpinVersionBeforeResponse;
16625
16626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16627 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
16628 }
16629
16630 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
16631 where
16632 V: serde::de::MapAccess<'de>,
16633 {
16634 let mut status__ = None;
16635 while let Some(k) = map_.next_key()? {
16636 match k {
16637 GeneratedField::Status => {
16638 if status__.is_some() {
16639 return Err(serde::de::Error::duplicate_field("status"));
16640 }
16641 status__ = map_.next_value()?;
16642 }
16643 }
16644 }
16645 Ok(UnpinVersionBeforeResponse {
16646 status: status__,
16647 })
16648 }
16649 }
16650 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
16651 }
16652}
16653impl serde::Serialize for UnpinVersionRequest {
16654 #[allow(deprecated)]
16655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16656 where
16657 S: serde::Serializer,
16658 {
16659 use serde::ser::SerializeStruct;
16660 let mut len = 0;
16661 if self.context_id != 0 {
16662 len += 1;
16663 }
16664 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
16665 if self.context_id != 0 {
16666 struct_ser.serialize_field("contextId", &self.context_id)?;
16667 }
16668 struct_ser.end()
16669 }
16670}
16671impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
16672 #[allow(deprecated)]
16673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16674 where
16675 D: serde::Deserializer<'de>,
16676 {
16677 const FIELDS: &[&str] = &[
16678 "context_id",
16679 "contextId",
16680 ];
16681
16682 #[allow(clippy::enum_variant_names)]
16683 enum GeneratedField {
16684 ContextId,
16685 }
16686 impl<'de> serde::Deserialize<'de> for GeneratedField {
16687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16688 where
16689 D: serde::Deserializer<'de>,
16690 {
16691 struct GeneratedVisitor;
16692
16693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16694 type Value = GeneratedField;
16695
16696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16697 write!(formatter, "expected one of: {:?}", &FIELDS)
16698 }
16699
16700 #[allow(unused_variables)]
16701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16702 where
16703 E: serde::de::Error,
16704 {
16705 match value {
16706 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
16707 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16708 }
16709 }
16710 }
16711 deserializer.deserialize_identifier(GeneratedVisitor)
16712 }
16713 }
16714 struct GeneratedVisitor;
16715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16716 type Value = UnpinVersionRequest;
16717
16718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16719 formatter.write_str("struct hummock.UnpinVersionRequest")
16720 }
16721
16722 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
16723 where
16724 V: serde::de::MapAccess<'de>,
16725 {
16726 let mut context_id__ = None;
16727 while let Some(k) = map_.next_key()? {
16728 match k {
16729 GeneratedField::ContextId => {
16730 if context_id__.is_some() {
16731 return Err(serde::de::Error::duplicate_field("contextId"));
16732 }
16733 context_id__ =
16734 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16735 ;
16736 }
16737 }
16738 }
16739 Ok(UnpinVersionRequest {
16740 context_id: context_id__.unwrap_or_default(),
16741 })
16742 }
16743 }
16744 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
16745 }
16746}
16747impl serde::Serialize for UnpinVersionResponse {
16748 #[allow(deprecated)]
16749 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16750 where
16751 S: serde::Serializer,
16752 {
16753 use serde::ser::SerializeStruct;
16754 let mut len = 0;
16755 if self.status.is_some() {
16756 len += 1;
16757 }
16758 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
16759 if let Some(v) = self.status.as_ref() {
16760 struct_ser.serialize_field("status", v)?;
16761 }
16762 struct_ser.end()
16763 }
16764}
16765impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
16766 #[allow(deprecated)]
16767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16768 where
16769 D: serde::Deserializer<'de>,
16770 {
16771 const FIELDS: &[&str] = &[
16772 "status",
16773 ];
16774
16775 #[allow(clippy::enum_variant_names)]
16776 enum GeneratedField {
16777 Status,
16778 }
16779 impl<'de> serde::Deserialize<'de> for GeneratedField {
16780 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16781 where
16782 D: serde::Deserializer<'de>,
16783 {
16784 struct GeneratedVisitor;
16785
16786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16787 type Value = GeneratedField;
16788
16789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16790 write!(formatter, "expected one of: {:?}", &FIELDS)
16791 }
16792
16793 #[allow(unused_variables)]
16794 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16795 where
16796 E: serde::de::Error,
16797 {
16798 match value {
16799 "status" => Ok(GeneratedField::Status),
16800 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16801 }
16802 }
16803 }
16804 deserializer.deserialize_identifier(GeneratedVisitor)
16805 }
16806 }
16807 struct GeneratedVisitor;
16808 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16809 type Value = UnpinVersionResponse;
16810
16811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16812 formatter.write_str("struct hummock.UnpinVersionResponse")
16813 }
16814
16815 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
16816 where
16817 V: serde::de::MapAccess<'de>,
16818 {
16819 let mut status__ = None;
16820 while let Some(k) = map_.next_key()? {
16821 match k {
16822 GeneratedField::Status => {
16823 if status__.is_some() {
16824 return Err(serde::de::Error::duplicate_field("status"));
16825 }
16826 status__ = map_.next_value()?;
16827 }
16828 }
16829 }
16830 Ok(UnpinVersionResponse {
16831 status: status__,
16832 })
16833 }
16834 }
16835 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
16836 }
16837}
16838impl serde::Serialize for VacuumTask {
16839 #[allow(deprecated)]
16840 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16841 where
16842 S: serde::Serializer,
16843 {
16844 use serde::ser::SerializeStruct;
16845 let mut len = 0;
16846 if !self.sstable_object_ids.is_empty() {
16847 len += 1;
16848 }
16849 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
16850 if !self.sstable_object_ids.is_empty() {
16851 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16852 }
16853 struct_ser.end()
16854 }
16855}
16856impl<'de> serde::Deserialize<'de> for VacuumTask {
16857 #[allow(deprecated)]
16858 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16859 where
16860 D: serde::Deserializer<'de>,
16861 {
16862 const FIELDS: &[&str] = &[
16863 "sstable_object_ids",
16864 "sstableObjectIds",
16865 ];
16866
16867 #[allow(clippy::enum_variant_names)]
16868 enum GeneratedField {
16869 SstableObjectIds,
16870 }
16871 impl<'de> serde::Deserialize<'de> for GeneratedField {
16872 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16873 where
16874 D: serde::Deserializer<'de>,
16875 {
16876 struct GeneratedVisitor;
16877
16878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16879 type Value = GeneratedField;
16880
16881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16882 write!(formatter, "expected one of: {:?}", &FIELDS)
16883 }
16884
16885 #[allow(unused_variables)]
16886 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16887 where
16888 E: serde::de::Error,
16889 {
16890 match value {
16891 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
16892 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16893 }
16894 }
16895 }
16896 deserializer.deserialize_identifier(GeneratedVisitor)
16897 }
16898 }
16899 struct GeneratedVisitor;
16900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16901 type Value = VacuumTask;
16902
16903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16904 formatter.write_str("struct hummock.VacuumTask")
16905 }
16906
16907 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
16908 where
16909 V: serde::de::MapAccess<'de>,
16910 {
16911 let mut sstable_object_ids__ = None;
16912 while let Some(k) = map_.next_key()? {
16913 match k {
16914 GeneratedField::SstableObjectIds => {
16915 if sstable_object_ids__.is_some() {
16916 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
16917 }
16918 sstable_object_ids__ =
16919 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16920 .into_iter().map(|x| x.0).collect())
16921 ;
16922 }
16923 }
16924 }
16925 Ok(VacuumTask {
16926 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
16927 })
16928 }
16929 }
16930 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
16931 }
16932}
16933impl serde::Serialize for ValidationTask {
16934 #[allow(deprecated)]
16935 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16936 where
16937 S: serde::Serializer,
16938 {
16939 use serde::ser::SerializeStruct;
16940 let mut len = 0;
16941 if !self.sst_infos.is_empty() {
16942 len += 1;
16943 }
16944 if !self.sst_id_to_worker_id.is_empty() {
16945 len += 1;
16946 }
16947 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
16948 if !self.sst_infos.is_empty() {
16949 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
16950 }
16951 if !self.sst_id_to_worker_id.is_empty() {
16952 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
16953 }
16954 struct_ser.end()
16955 }
16956}
16957impl<'de> serde::Deserialize<'de> for ValidationTask {
16958 #[allow(deprecated)]
16959 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16960 where
16961 D: serde::Deserializer<'de>,
16962 {
16963 const FIELDS: &[&str] = &[
16964 "sst_infos",
16965 "sstInfos",
16966 "sst_id_to_worker_id",
16967 "sstIdToWorkerId",
16968 ];
16969
16970 #[allow(clippy::enum_variant_names)]
16971 enum GeneratedField {
16972 SstInfos,
16973 SstIdToWorkerId,
16974 }
16975 impl<'de> serde::Deserialize<'de> for GeneratedField {
16976 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16977 where
16978 D: serde::Deserializer<'de>,
16979 {
16980 struct GeneratedVisitor;
16981
16982 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16983 type Value = GeneratedField;
16984
16985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16986 write!(formatter, "expected one of: {:?}", &FIELDS)
16987 }
16988
16989 #[allow(unused_variables)]
16990 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16991 where
16992 E: serde::de::Error,
16993 {
16994 match value {
16995 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
16996 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
16997 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16998 }
16999 }
17000 }
17001 deserializer.deserialize_identifier(GeneratedVisitor)
17002 }
17003 }
17004 struct GeneratedVisitor;
17005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17006 type Value = ValidationTask;
17007
17008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17009 formatter.write_str("struct hummock.ValidationTask")
17010 }
17011
17012 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
17013 where
17014 V: serde::de::MapAccess<'de>,
17015 {
17016 let mut sst_infos__ = None;
17017 let mut sst_id_to_worker_id__ = None;
17018 while let Some(k) = map_.next_key()? {
17019 match k {
17020 GeneratedField::SstInfos => {
17021 if sst_infos__.is_some() {
17022 return Err(serde::de::Error::duplicate_field("sstInfos"));
17023 }
17024 sst_infos__ = Some(map_.next_value()?);
17025 }
17026 GeneratedField::SstIdToWorkerId => {
17027 if sst_id_to_worker_id__.is_some() {
17028 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
17029 }
17030 sst_id_to_worker_id__ = Some(
17031 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
17032 .into_iter().map(|(k,v)| (k.0, v.0)).collect()
17033 );
17034 }
17035 }
17036 }
17037 Ok(ValidationTask {
17038 sst_infos: sst_infos__.unwrap_or_default(),
17039 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
17040 })
17041 }
17042 }
17043 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
17044 }
17045}
17046impl serde::Serialize for VectorFileInfo {
17047 #[allow(deprecated)]
17048 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17049 where
17050 S: serde::Serializer,
17051 {
17052 use serde::ser::SerializeStruct;
17053 let mut len = 0;
17054 if self.object_id != 0 {
17055 len += 1;
17056 }
17057 if self.file_size != 0 {
17058 len += 1;
17059 }
17060 if self.start_vector_id != 0 {
17061 len += 1;
17062 }
17063 if self.vector_count != 0 {
17064 len += 1;
17065 }
17066 if self.meta_offset != 0 {
17067 len += 1;
17068 }
17069 let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
17070 if self.object_id != 0 {
17071 #[allow(clippy::needless_borrow)]
17072 #[allow(clippy::needless_borrows_for_generic_args)]
17073 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
17074 }
17075 if self.file_size != 0 {
17076 #[allow(clippy::needless_borrow)]
17077 #[allow(clippy::needless_borrows_for_generic_args)]
17078 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
17079 }
17080 if self.start_vector_id != 0 {
17081 #[allow(clippy::needless_borrow)]
17082 #[allow(clippy::needless_borrows_for_generic_args)]
17083 struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
17084 }
17085 if self.vector_count != 0 {
17086 struct_ser.serialize_field("vectorCount", &self.vector_count)?;
17087 }
17088 if self.meta_offset != 0 {
17089 #[allow(clippy::needless_borrow)]
17090 #[allow(clippy::needless_borrows_for_generic_args)]
17091 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
17092 }
17093 struct_ser.end()
17094 }
17095}
17096impl<'de> serde::Deserialize<'de> for VectorFileInfo {
17097 #[allow(deprecated)]
17098 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17099 where
17100 D: serde::Deserializer<'de>,
17101 {
17102 const FIELDS: &[&str] = &[
17103 "object_id",
17104 "objectId",
17105 "file_size",
17106 "fileSize",
17107 "start_vector_id",
17108 "startVectorId",
17109 "vector_count",
17110 "vectorCount",
17111 "meta_offset",
17112 "metaOffset",
17113 ];
17114
17115 #[allow(clippy::enum_variant_names)]
17116 enum GeneratedField {
17117 ObjectId,
17118 FileSize,
17119 StartVectorId,
17120 VectorCount,
17121 MetaOffset,
17122 }
17123 impl<'de> serde::Deserialize<'de> for GeneratedField {
17124 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17125 where
17126 D: serde::Deserializer<'de>,
17127 {
17128 struct GeneratedVisitor;
17129
17130 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17131 type Value = GeneratedField;
17132
17133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17134 write!(formatter, "expected one of: {:?}", &FIELDS)
17135 }
17136
17137 #[allow(unused_variables)]
17138 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17139 where
17140 E: serde::de::Error,
17141 {
17142 match value {
17143 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
17144 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
17145 "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
17146 "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
17147 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
17148 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17149 }
17150 }
17151 }
17152 deserializer.deserialize_identifier(GeneratedVisitor)
17153 }
17154 }
17155 struct GeneratedVisitor;
17156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17157 type Value = VectorFileInfo;
17158
17159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17160 formatter.write_str("struct hummock.VectorFileInfo")
17161 }
17162
17163 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
17164 where
17165 V: serde::de::MapAccess<'de>,
17166 {
17167 let mut object_id__ = None;
17168 let mut file_size__ = None;
17169 let mut start_vector_id__ = None;
17170 let mut vector_count__ = None;
17171 let mut meta_offset__ = None;
17172 while let Some(k) = map_.next_key()? {
17173 match k {
17174 GeneratedField::ObjectId => {
17175 if object_id__.is_some() {
17176 return Err(serde::de::Error::duplicate_field("objectId"));
17177 }
17178 object_id__ =
17179 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17180 ;
17181 }
17182 GeneratedField::FileSize => {
17183 if file_size__.is_some() {
17184 return Err(serde::de::Error::duplicate_field("fileSize"));
17185 }
17186 file_size__ =
17187 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17188 ;
17189 }
17190 GeneratedField::StartVectorId => {
17191 if start_vector_id__.is_some() {
17192 return Err(serde::de::Error::duplicate_field("startVectorId"));
17193 }
17194 start_vector_id__ =
17195 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17196 ;
17197 }
17198 GeneratedField::VectorCount => {
17199 if vector_count__.is_some() {
17200 return Err(serde::de::Error::duplicate_field("vectorCount"));
17201 }
17202 vector_count__ =
17203 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17204 ;
17205 }
17206 GeneratedField::MetaOffset => {
17207 if meta_offset__.is_some() {
17208 return Err(serde::de::Error::duplicate_field("metaOffset"));
17209 }
17210 meta_offset__ =
17211 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17212 ;
17213 }
17214 }
17215 }
17216 Ok(VectorFileInfo {
17217 object_id: object_id__.unwrap_or_default(),
17218 file_size: file_size__.unwrap_or_default(),
17219 start_vector_id: start_vector_id__.unwrap_or_default(),
17220 vector_count: vector_count__.unwrap_or_default(),
17221 meta_offset: meta_offset__.unwrap_or_default(),
17222 })
17223 }
17224 }
17225 deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
17226 }
17227}
17228impl serde::Serialize for VectorIndex {
17229 #[allow(deprecated)]
17230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17231 where
17232 S: serde::Serializer,
17233 {
17234 use serde::ser::SerializeStruct;
17235 let mut len = 0;
17236 if self.dimension != 0 {
17237 len += 1;
17238 }
17239 if self.distance_type != 0 {
17240 len += 1;
17241 }
17242 if self.variant.is_some() {
17243 len += 1;
17244 }
17245 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
17246 if self.dimension != 0 {
17247 struct_ser.serialize_field("dimension", &self.dimension)?;
17248 }
17249 if self.distance_type != 0 {
17250 let v = super::common::DistanceType::try_from(self.distance_type)
17251 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
17252 struct_ser.serialize_field("distanceType", &v)?;
17253 }
17254 if let Some(v) = self.variant.as_ref() {
17255 match v {
17256 vector_index::Variant::Flat(v) => {
17257 struct_ser.serialize_field("flat", v)?;
17258 }
17259 vector_index::Variant::HnswFlat(v) => {
17260 struct_ser.serialize_field("hnswFlat", v)?;
17261 }
17262 }
17263 }
17264 struct_ser.end()
17265 }
17266}
17267impl<'de> serde::Deserialize<'de> for VectorIndex {
17268 #[allow(deprecated)]
17269 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17270 where
17271 D: serde::Deserializer<'de>,
17272 {
17273 const FIELDS: &[&str] = &[
17274 "dimension",
17275 "distance_type",
17276 "distanceType",
17277 "flat",
17278 "hnsw_flat",
17279 "hnswFlat",
17280 ];
17281
17282 #[allow(clippy::enum_variant_names)]
17283 enum GeneratedField {
17284 Dimension,
17285 DistanceType,
17286 Flat,
17287 HnswFlat,
17288 }
17289 impl<'de> serde::Deserialize<'de> for GeneratedField {
17290 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17291 where
17292 D: serde::Deserializer<'de>,
17293 {
17294 struct GeneratedVisitor;
17295
17296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17297 type Value = GeneratedField;
17298
17299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17300 write!(formatter, "expected one of: {:?}", &FIELDS)
17301 }
17302
17303 #[allow(unused_variables)]
17304 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17305 where
17306 E: serde::de::Error,
17307 {
17308 match value {
17309 "dimension" => Ok(GeneratedField::Dimension),
17310 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
17311 "flat" => Ok(GeneratedField::Flat),
17312 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
17313 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17314 }
17315 }
17316 }
17317 deserializer.deserialize_identifier(GeneratedVisitor)
17318 }
17319 }
17320 struct GeneratedVisitor;
17321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17322 type Value = VectorIndex;
17323
17324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17325 formatter.write_str("struct hummock.VectorIndex")
17326 }
17327
17328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
17329 where
17330 V: serde::de::MapAccess<'de>,
17331 {
17332 let mut dimension__ = None;
17333 let mut distance_type__ = None;
17334 let mut variant__ = None;
17335 while let Some(k) = map_.next_key()? {
17336 match k {
17337 GeneratedField::Dimension => {
17338 if dimension__.is_some() {
17339 return Err(serde::de::Error::duplicate_field("dimension"));
17340 }
17341 dimension__ =
17342 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17343 ;
17344 }
17345 GeneratedField::DistanceType => {
17346 if distance_type__.is_some() {
17347 return Err(serde::de::Error::duplicate_field("distanceType"));
17348 }
17349 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
17350 }
17351 GeneratedField::Flat => {
17352 if variant__.is_some() {
17353 return Err(serde::de::Error::duplicate_field("flat"));
17354 }
17355 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
17356;
17357 }
17358 GeneratedField::HnswFlat => {
17359 if variant__.is_some() {
17360 return Err(serde::de::Error::duplicate_field("hnswFlat"));
17361 }
17362 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::HnswFlat)
17363;
17364 }
17365 }
17366 }
17367 Ok(VectorIndex {
17368 dimension: dimension__.unwrap_or_default(),
17369 distance_type: distance_type__.unwrap_or_default(),
17370 variant: variant__,
17371 })
17372 }
17373 }
17374 deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
17375 }
17376}
17377impl serde::Serialize for VectorIndexDelta {
17378 #[allow(deprecated)]
17379 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17380 where
17381 S: serde::Serializer,
17382 {
17383 use serde::ser::SerializeStruct;
17384 let mut len = 0;
17385 if self.delta.is_some() {
17386 len += 1;
17387 }
17388 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
17389 if let Some(v) = self.delta.as_ref() {
17390 match v {
17391 vector_index_delta::Delta::Init(v) => {
17392 struct_ser.serialize_field("init", v)?;
17393 }
17394 vector_index_delta::Delta::Adds(v) => {
17395 struct_ser.serialize_field("adds", v)?;
17396 }
17397 }
17398 }
17399 struct_ser.end()
17400 }
17401}
17402impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
17403 #[allow(deprecated)]
17404 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17405 where
17406 D: serde::Deserializer<'de>,
17407 {
17408 const FIELDS: &[&str] = &[
17409 "init",
17410 "adds",
17411 ];
17412
17413 #[allow(clippy::enum_variant_names)]
17414 enum GeneratedField {
17415 Init,
17416 Adds,
17417 }
17418 impl<'de> serde::Deserialize<'de> for GeneratedField {
17419 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17420 where
17421 D: serde::Deserializer<'de>,
17422 {
17423 struct GeneratedVisitor;
17424
17425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17426 type Value = GeneratedField;
17427
17428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17429 write!(formatter, "expected one of: {:?}", &FIELDS)
17430 }
17431
17432 #[allow(unused_variables)]
17433 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17434 where
17435 E: serde::de::Error,
17436 {
17437 match value {
17438 "init" => Ok(GeneratedField::Init),
17439 "adds" => Ok(GeneratedField::Adds),
17440 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17441 }
17442 }
17443 }
17444 deserializer.deserialize_identifier(GeneratedVisitor)
17445 }
17446 }
17447 struct GeneratedVisitor;
17448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17449 type Value = VectorIndexDelta;
17450
17451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17452 formatter.write_str("struct hummock.VectorIndexDelta")
17453 }
17454
17455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
17456 where
17457 V: serde::de::MapAccess<'de>,
17458 {
17459 let mut delta__ = None;
17460 while let Some(k) = map_.next_key()? {
17461 match k {
17462 GeneratedField::Init => {
17463 if delta__.is_some() {
17464 return Err(serde::de::Error::duplicate_field("init"));
17465 }
17466 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
17467;
17468 }
17469 GeneratedField::Adds => {
17470 if delta__.is_some() {
17471 return Err(serde::de::Error::duplicate_field("adds"));
17472 }
17473 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
17474;
17475 }
17476 }
17477 }
17478 Ok(VectorIndexDelta {
17479 delta: delta__,
17480 })
17481 }
17482 }
17483 deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
17484 }
17485}
17486impl serde::Serialize for vector_index_delta::VectorIndexAdd {
17487 #[allow(deprecated)]
17488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17489 where
17490 S: serde::Serializer,
17491 {
17492 use serde::ser::SerializeStruct;
17493 let mut len = 0;
17494 if self.add.is_some() {
17495 len += 1;
17496 }
17497 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
17498 if let Some(v) = self.add.as_ref() {
17499 match v {
17500 vector_index_delta::vector_index_add::Add::Flat(v) => {
17501 struct_ser.serialize_field("flat", v)?;
17502 }
17503 vector_index_delta::vector_index_add::Add::HnswFlat(v) => {
17504 struct_ser.serialize_field("hnswFlat", v)?;
17505 }
17506 }
17507 }
17508 struct_ser.end()
17509 }
17510}
17511impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
17512 #[allow(deprecated)]
17513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17514 where
17515 D: serde::Deserializer<'de>,
17516 {
17517 const FIELDS: &[&str] = &[
17518 "flat",
17519 "hnsw_flat",
17520 "hnswFlat",
17521 ];
17522
17523 #[allow(clippy::enum_variant_names)]
17524 enum GeneratedField {
17525 Flat,
17526 HnswFlat,
17527 }
17528 impl<'de> serde::Deserialize<'de> for GeneratedField {
17529 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17530 where
17531 D: serde::Deserializer<'de>,
17532 {
17533 struct GeneratedVisitor;
17534
17535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17536 type Value = GeneratedField;
17537
17538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17539 write!(formatter, "expected one of: {:?}", &FIELDS)
17540 }
17541
17542 #[allow(unused_variables)]
17543 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17544 where
17545 E: serde::de::Error,
17546 {
17547 match value {
17548 "flat" => Ok(GeneratedField::Flat),
17549 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
17550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17551 }
17552 }
17553 }
17554 deserializer.deserialize_identifier(GeneratedVisitor)
17555 }
17556 }
17557 struct GeneratedVisitor;
17558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17559 type Value = vector_index_delta::VectorIndexAdd;
17560
17561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17562 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
17563 }
17564
17565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
17566 where
17567 V: serde::de::MapAccess<'de>,
17568 {
17569 let mut add__ = None;
17570 while let Some(k) = map_.next_key()? {
17571 match k {
17572 GeneratedField::Flat => {
17573 if add__.is_some() {
17574 return Err(serde::de::Error::duplicate_field("flat"));
17575 }
17576 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
17577;
17578 }
17579 GeneratedField::HnswFlat => {
17580 if add__.is_some() {
17581 return Err(serde::de::Error::duplicate_field("hnswFlat"));
17582 }
17583 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::HnswFlat)
17584;
17585 }
17586 }
17587 }
17588 Ok(vector_index_delta::VectorIndexAdd {
17589 add: add__,
17590 })
17591 }
17592 }
17593 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
17594 }
17595}
17596impl serde::Serialize for vector_index_delta::VectorIndexAdds {
17597 #[allow(deprecated)]
17598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17599 where
17600 S: serde::Serializer,
17601 {
17602 use serde::ser::SerializeStruct;
17603 let mut len = 0;
17604 if !self.adds.is_empty() {
17605 len += 1;
17606 }
17607 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
17608 if !self.adds.is_empty() {
17609 struct_ser.serialize_field("adds", &self.adds)?;
17610 }
17611 struct_ser.end()
17612 }
17613}
17614impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
17615 #[allow(deprecated)]
17616 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17617 where
17618 D: serde::Deserializer<'de>,
17619 {
17620 const FIELDS: &[&str] = &[
17621 "adds",
17622 ];
17623
17624 #[allow(clippy::enum_variant_names)]
17625 enum GeneratedField {
17626 Adds,
17627 }
17628 impl<'de> serde::Deserialize<'de> for GeneratedField {
17629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17630 where
17631 D: serde::Deserializer<'de>,
17632 {
17633 struct GeneratedVisitor;
17634
17635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17636 type Value = GeneratedField;
17637
17638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17639 write!(formatter, "expected one of: {:?}", &FIELDS)
17640 }
17641
17642 #[allow(unused_variables)]
17643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17644 where
17645 E: serde::de::Error,
17646 {
17647 match value {
17648 "adds" => Ok(GeneratedField::Adds),
17649 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17650 }
17651 }
17652 }
17653 deserializer.deserialize_identifier(GeneratedVisitor)
17654 }
17655 }
17656 struct GeneratedVisitor;
17657 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17658 type Value = vector_index_delta::VectorIndexAdds;
17659
17660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17661 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
17662 }
17663
17664 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
17665 where
17666 V: serde::de::MapAccess<'de>,
17667 {
17668 let mut adds__ = None;
17669 while let Some(k) = map_.next_key()? {
17670 match k {
17671 GeneratedField::Adds => {
17672 if adds__.is_some() {
17673 return Err(serde::de::Error::duplicate_field("adds"));
17674 }
17675 adds__ = Some(map_.next_value()?);
17676 }
17677 }
17678 }
17679 Ok(vector_index_delta::VectorIndexAdds {
17680 adds: adds__.unwrap_or_default(),
17681 })
17682 }
17683 }
17684 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
17685 }
17686}
17687impl serde::Serialize for vector_index_delta::VectorIndexInit {
17688 #[allow(deprecated)]
17689 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17690 where
17691 S: serde::Serializer,
17692 {
17693 use serde::ser::SerializeStruct;
17694 let mut len = 0;
17695 if self.info.is_some() {
17696 len += 1;
17697 }
17698 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
17699 if let Some(v) = self.info.as_ref() {
17700 struct_ser.serialize_field("info", v)?;
17701 }
17702 struct_ser.end()
17703 }
17704}
17705impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
17706 #[allow(deprecated)]
17707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17708 where
17709 D: serde::Deserializer<'de>,
17710 {
17711 const FIELDS: &[&str] = &[
17712 "info",
17713 ];
17714
17715 #[allow(clippy::enum_variant_names)]
17716 enum GeneratedField {
17717 Info,
17718 }
17719 impl<'de> serde::Deserialize<'de> for GeneratedField {
17720 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17721 where
17722 D: serde::Deserializer<'de>,
17723 {
17724 struct GeneratedVisitor;
17725
17726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17727 type Value = GeneratedField;
17728
17729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17730 write!(formatter, "expected one of: {:?}", &FIELDS)
17731 }
17732
17733 #[allow(unused_variables)]
17734 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17735 where
17736 E: serde::de::Error,
17737 {
17738 match value {
17739 "info" => Ok(GeneratedField::Info),
17740 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17741 }
17742 }
17743 }
17744 deserializer.deserialize_identifier(GeneratedVisitor)
17745 }
17746 }
17747 struct GeneratedVisitor;
17748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17749 type Value = vector_index_delta::VectorIndexInit;
17750
17751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17752 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
17753 }
17754
17755 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
17756 where
17757 V: serde::de::MapAccess<'de>,
17758 {
17759 let mut info__ = None;
17760 while let Some(k) = map_.next_key()? {
17761 match k {
17762 GeneratedField::Info => {
17763 if info__.is_some() {
17764 return Err(serde::de::Error::duplicate_field("info"));
17765 }
17766 info__ = map_.next_value()?;
17767 }
17768 }
17769 }
17770 Ok(vector_index_delta::VectorIndexInit {
17771 info: info__,
17772 })
17773 }
17774 }
17775 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
17776 }
17777}
17778impl serde::Serialize for VectorIndexObject {
17779 #[allow(deprecated)]
17780 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17781 where
17782 S: serde::Serializer,
17783 {
17784 use serde::ser::SerializeStruct;
17785 let mut len = 0;
17786 if self.id != 0 {
17787 len += 1;
17788 }
17789 if self.object_type != 0 {
17790 len += 1;
17791 }
17792 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
17793 if self.id != 0 {
17794 #[allow(clippy::needless_borrow)]
17795 #[allow(clippy::needless_borrows_for_generic_args)]
17796 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
17797 }
17798 if self.object_type != 0 {
17799 let v = VectorIndexObjectType::try_from(self.object_type)
17800 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
17801 struct_ser.serialize_field("objectType", &v)?;
17802 }
17803 struct_ser.end()
17804 }
17805}
17806impl<'de> serde::Deserialize<'de> for VectorIndexObject {
17807 #[allow(deprecated)]
17808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17809 where
17810 D: serde::Deserializer<'de>,
17811 {
17812 const FIELDS: &[&str] = &[
17813 "id",
17814 "object_type",
17815 "objectType",
17816 ];
17817
17818 #[allow(clippy::enum_variant_names)]
17819 enum GeneratedField {
17820 Id,
17821 ObjectType,
17822 }
17823 impl<'de> serde::Deserialize<'de> for GeneratedField {
17824 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17825 where
17826 D: serde::Deserializer<'de>,
17827 {
17828 struct GeneratedVisitor;
17829
17830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17831 type Value = GeneratedField;
17832
17833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17834 write!(formatter, "expected one of: {:?}", &FIELDS)
17835 }
17836
17837 #[allow(unused_variables)]
17838 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17839 where
17840 E: serde::de::Error,
17841 {
17842 match value {
17843 "id" => Ok(GeneratedField::Id),
17844 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
17845 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17846 }
17847 }
17848 }
17849 deserializer.deserialize_identifier(GeneratedVisitor)
17850 }
17851 }
17852 struct GeneratedVisitor;
17853 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17854 type Value = VectorIndexObject;
17855
17856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17857 formatter.write_str("struct hummock.VectorIndexObject")
17858 }
17859
17860 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
17861 where
17862 V: serde::de::MapAccess<'de>,
17863 {
17864 let mut id__ = None;
17865 let mut object_type__ = None;
17866 while let Some(k) = map_.next_key()? {
17867 match k {
17868 GeneratedField::Id => {
17869 if id__.is_some() {
17870 return Err(serde::de::Error::duplicate_field("id"));
17871 }
17872 id__ =
17873 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17874 ;
17875 }
17876 GeneratedField::ObjectType => {
17877 if object_type__.is_some() {
17878 return Err(serde::de::Error::duplicate_field("objectType"));
17879 }
17880 object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
17881 }
17882 }
17883 }
17884 Ok(VectorIndexObject {
17885 id: id__.unwrap_or_default(),
17886 object_type: object_type__.unwrap_or_default(),
17887 })
17888 }
17889 }
17890 deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
17891 }
17892}
17893impl serde::Serialize for VectorIndexObjectType {
17894 #[allow(deprecated)]
17895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17896 where
17897 S: serde::Serializer,
17898 {
17899 let variant = match self {
17900 Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17901 Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
17902 Self::VectorIndexObjectHnswGraph => "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
17903 };
17904 serializer.serialize_str(variant)
17905 }
17906}
17907impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
17908 #[allow(deprecated)]
17909 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17910 where
17911 D: serde::Deserializer<'de>,
17912 {
17913 const FIELDS: &[&str] = &[
17914 "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17915 "VECTOR_INDEX_OBJECT_VECTOR",
17916 "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
17917 ];
17918
17919 struct GeneratedVisitor;
17920
17921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17922 type Value = VectorIndexObjectType;
17923
17924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17925 write!(formatter, "expected one of: {:?}", &FIELDS)
17926 }
17927
17928 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17929 where
17930 E: serde::de::Error,
17931 {
17932 i32::try_from(v)
17933 .ok()
17934 .and_then(|x| x.try_into().ok())
17935 .ok_or_else(|| {
17936 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17937 })
17938 }
17939
17940 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17941 where
17942 E: serde::de::Error,
17943 {
17944 i32::try_from(v)
17945 .ok()
17946 .and_then(|x| x.try_into().ok())
17947 .ok_or_else(|| {
17948 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17949 })
17950 }
17951
17952 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17953 where
17954 E: serde::de::Error,
17955 {
17956 match value {
17957 "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
17958 "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
17959 "VECTOR_INDEX_OBJECT_HNSW_GRAPH" => Ok(VectorIndexObjectType::VectorIndexObjectHnswGraph),
17960 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17961 }
17962 }
17963 }
17964 deserializer.deserialize_any(GeneratedVisitor)
17965 }
17966}
17967impl serde::Serialize for VersionUpdatePayload {
17968 #[allow(deprecated)]
17969 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17970 where
17971 S: serde::Serializer,
17972 {
17973 use serde::ser::SerializeStruct;
17974 let mut len = 0;
17975 if self.payload.is_some() {
17976 len += 1;
17977 }
17978 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
17979 if let Some(v) = self.payload.as_ref() {
17980 match v {
17981 version_update_payload::Payload::VersionDeltas(v) => {
17982 struct_ser.serialize_field("versionDeltas", v)?;
17983 }
17984 version_update_payload::Payload::PinnedVersion(v) => {
17985 struct_ser.serialize_field("pinnedVersion", v)?;
17986 }
17987 }
17988 }
17989 struct_ser.end()
17990 }
17991}
17992impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
17993 #[allow(deprecated)]
17994 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17995 where
17996 D: serde::Deserializer<'de>,
17997 {
17998 const FIELDS: &[&str] = &[
17999 "version_deltas",
18000 "versionDeltas",
18001 "pinned_version",
18002 "pinnedVersion",
18003 ];
18004
18005 #[allow(clippy::enum_variant_names)]
18006 enum GeneratedField {
18007 VersionDeltas,
18008 PinnedVersion,
18009 }
18010 impl<'de> serde::Deserialize<'de> for GeneratedField {
18011 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18012 where
18013 D: serde::Deserializer<'de>,
18014 {
18015 struct GeneratedVisitor;
18016
18017 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18018 type Value = GeneratedField;
18019
18020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18021 write!(formatter, "expected one of: {:?}", &FIELDS)
18022 }
18023
18024 #[allow(unused_variables)]
18025 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18026 where
18027 E: serde::de::Error,
18028 {
18029 match value {
18030 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
18031 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
18032 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18033 }
18034 }
18035 }
18036 deserializer.deserialize_identifier(GeneratedVisitor)
18037 }
18038 }
18039 struct GeneratedVisitor;
18040 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18041 type Value = VersionUpdatePayload;
18042
18043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18044 formatter.write_str("struct hummock.VersionUpdatePayload")
18045 }
18046
18047 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
18048 where
18049 V: serde::de::MapAccess<'de>,
18050 {
18051 let mut payload__ = None;
18052 while let Some(k) = map_.next_key()? {
18053 match k {
18054 GeneratedField::VersionDeltas => {
18055 if payload__.is_some() {
18056 return Err(serde::de::Error::duplicate_field("versionDeltas"));
18057 }
18058 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
18059;
18060 }
18061 GeneratedField::PinnedVersion => {
18062 if payload__.is_some() {
18063 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
18064 }
18065 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
18066;
18067 }
18068 }
18069 }
18070 Ok(VersionUpdatePayload {
18071 payload: payload__,
18072 })
18073 }
18074 }
18075 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
18076 }
18077}
18078impl serde::Serialize for VnodeWatermark {
18079 #[allow(deprecated)]
18080 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18081 where
18082 S: serde::Serializer,
18083 {
18084 use serde::ser::SerializeStruct;
18085 let mut len = 0;
18086 if !self.watermark.is_empty() {
18087 len += 1;
18088 }
18089 if self.vnode_bitmap.is_some() {
18090 len += 1;
18091 }
18092 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
18093 if !self.watermark.is_empty() {
18094 #[allow(clippy::needless_borrow)]
18095 #[allow(clippy::needless_borrows_for_generic_args)]
18096 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
18097 }
18098 if let Some(v) = self.vnode_bitmap.as_ref() {
18099 struct_ser.serialize_field("vnodeBitmap", v)?;
18100 }
18101 struct_ser.end()
18102 }
18103}
18104impl<'de> serde::Deserialize<'de> for VnodeWatermark {
18105 #[allow(deprecated)]
18106 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18107 where
18108 D: serde::Deserializer<'de>,
18109 {
18110 const FIELDS: &[&str] = &[
18111 "watermark",
18112 "vnode_bitmap",
18113 "vnodeBitmap",
18114 ];
18115
18116 #[allow(clippy::enum_variant_names)]
18117 enum GeneratedField {
18118 Watermark,
18119 VnodeBitmap,
18120 }
18121 impl<'de> serde::Deserialize<'de> for GeneratedField {
18122 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18123 where
18124 D: serde::Deserializer<'de>,
18125 {
18126 struct GeneratedVisitor;
18127
18128 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18129 type Value = GeneratedField;
18130
18131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18132 write!(formatter, "expected one of: {:?}", &FIELDS)
18133 }
18134
18135 #[allow(unused_variables)]
18136 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18137 where
18138 E: serde::de::Error,
18139 {
18140 match value {
18141 "watermark" => Ok(GeneratedField::Watermark),
18142 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
18143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18144 }
18145 }
18146 }
18147 deserializer.deserialize_identifier(GeneratedVisitor)
18148 }
18149 }
18150 struct GeneratedVisitor;
18151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18152 type Value = VnodeWatermark;
18153
18154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18155 formatter.write_str("struct hummock.VnodeWatermark")
18156 }
18157
18158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
18159 where
18160 V: serde::de::MapAccess<'de>,
18161 {
18162 let mut watermark__ = None;
18163 let mut vnode_bitmap__ = None;
18164 while let Some(k) = map_.next_key()? {
18165 match k {
18166 GeneratedField::Watermark => {
18167 if watermark__.is_some() {
18168 return Err(serde::de::Error::duplicate_field("watermark"));
18169 }
18170 watermark__ =
18171 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
18172 ;
18173 }
18174 GeneratedField::VnodeBitmap => {
18175 if vnode_bitmap__.is_some() {
18176 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
18177 }
18178 vnode_bitmap__ = map_.next_value()?;
18179 }
18180 }
18181 }
18182 Ok(VnodeWatermark {
18183 watermark: watermark__.unwrap_or_default(),
18184 vnode_bitmap: vnode_bitmap__,
18185 })
18186 }
18187 }
18188 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
18189 }
18190}
18191impl serde::Serialize for WriteLimits {
18192 #[allow(deprecated)]
18193 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18194 where
18195 S: serde::Serializer,
18196 {
18197 use serde::ser::SerializeStruct;
18198 let mut len = 0;
18199 if !self.write_limits.is_empty() {
18200 len += 1;
18201 }
18202 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
18203 if !self.write_limits.is_empty() {
18204 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
18205 }
18206 struct_ser.end()
18207 }
18208}
18209impl<'de> serde::Deserialize<'de> for WriteLimits {
18210 #[allow(deprecated)]
18211 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18212 where
18213 D: serde::Deserializer<'de>,
18214 {
18215 const FIELDS: &[&str] = &[
18216 "write_limits",
18217 "writeLimits",
18218 ];
18219
18220 #[allow(clippy::enum_variant_names)]
18221 enum GeneratedField {
18222 WriteLimits,
18223 }
18224 impl<'de> serde::Deserialize<'de> for GeneratedField {
18225 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18226 where
18227 D: serde::Deserializer<'de>,
18228 {
18229 struct GeneratedVisitor;
18230
18231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18232 type Value = GeneratedField;
18233
18234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18235 write!(formatter, "expected one of: {:?}", &FIELDS)
18236 }
18237
18238 #[allow(unused_variables)]
18239 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18240 where
18241 E: serde::de::Error,
18242 {
18243 match value {
18244 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
18245 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18246 }
18247 }
18248 }
18249 deserializer.deserialize_identifier(GeneratedVisitor)
18250 }
18251 }
18252 struct GeneratedVisitor;
18253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18254 type Value = WriteLimits;
18255
18256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18257 formatter.write_str("struct hummock.WriteLimits")
18258 }
18259
18260 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
18261 where
18262 V: serde::de::MapAccess<'de>,
18263 {
18264 let mut write_limits__ = None;
18265 while let Some(k) = map_.next_key()? {
18266 match k {
18267 GeneratedField::WriteLimits => {
18268 if write_limits__.is_some() {
18269 return Err(serde::de::Error::duplicate_field("writeLimits"));
18270 }
18271 write_limits__ = Some(
18272 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
18273 .into_iter().map(|(k,v)| (k.0, v)).collect()
18274 );
18275 }
18276 }
18277 }
18278 Ok(WriteLimits {
18279 write_limits: write_limits__.unwrap_or_default(),
18280 })
18281 }
18282 }
18283 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
18284 }
18285}
18286impl serde::Serialize for write_limits::WriteLimit {
18287 #[allow(deprecated)]
18288 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18289 where
18290 S: serde::Serializer,
18291 {
18292 use serde::ser::SerializeStruct;
18293 let mut len = 0;
18294 if !self.table_ids.is_empty() {
18295 len += 1;
18296 }
18297 if !self.reason.is_empty() {
18298 len += 1;
18299 }
18300 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
18301 if !self.table_ids.is_empty() {
18302 struct_ser.serialize_field("tableIds", &self.table_ids)?;
18303 }
18304 if !self.reason.is_empty() {
18305 struct_ser.serialize_field("reason", &self.reason)?;
18306 }
18307 struct_ser.end()
18308 }
18309}
18310impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
18311 #[allow(deprecated)]
18312 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18313 where
18314 D: serde::Deserializer<'de>,
18315 {
18316 const FIELDS: &[&str] = &[
18317 "table_ids",
18318 "tableIds",
18319 "reason",
18320 ];
18321
18322 #[allow(clippy::enum_variant_names)]
18323 enum GeneratedField {
18324 TableIds,
18325 Reason,
18326 }
18327 impl<'de> serde::Deserialize<'de> for GeneratedField {
18328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18329 where
18330 D: serde::Deserializer<'de>,
18331 {
18332 struct GeneratedVisitor;
18333
18334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18335 type Value = GeneratedField;
18336
18337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18338 write!(formatter, "expected one of: {:?}", &FIELDS)
18339 }
18340
18341 #[allow(unused_variables)]
18342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18343 where
18344 E: serde::de::Error,
18345 {
18346 match value {
18347 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
18348 "reason" => Ok(GeneratedField::Reason),
18349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18350 }
18351 }
18352 }
18353 deserializer.deserialize_identifier(GeneratedVisitor)
18354 }
18355 }
18356 struct GeneratedVisitor;
18357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18358 type Value = write_limits::WriteLimit;
18359
18360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18361 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
18362 }
18363
18364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
18365 where
18366 V: serde::de::MapAccess<'de>,
18367 {
18368 let mut table_ids__ = None;
18369 let mut reason__ = None;
18370 while let Some(k) = map_.next_key()? {
18371 match k {
18372 GeneratedField::TableIds => {
18373 if table_ids__.is_some() {
18374 return Err(serde::de::Error::duplicate_field("tableIds"));
18375 }
18376 table_ids__ =
18377 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18378 .into_iter().map(|x| x.0).collect())
18379 ;
18380 }
18381 GeneratedField::Reason => {
18382 if reason__.is_some() {
18383 return Err(serde::de::Error::duplicate_field("reason"));
18384 }
18385 reason__ = Some(map_.next_value()?);
18386 }
18387 }
18388 }
18389 Ok(write_limits::WriteLimit {
18390 table_ids: table_ids__.unwrap_or_default(),
18391 reason: reason__.unwrap_or_default(),
18392 })
18393 }
18394 }
18395 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
18396 }
18397}