1#![allow(clippy::useless_conversion)]
2use crate::hummock::*;
3impl serde::Serialize for BloomFilterType {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 let variant = match self {
10 Self::BloomFilterUnspecified => "BLOOM_FILTER_UNSPECIFIED",
11 Self::Sstable => "SSTABLE",
12 Self::Blocked => "BLOCKED",
13 };
14 serializer.serialize_str(variant)
15 }
16}
17impl<'de> serde::Deserialize<'de> for BloomFilterType {
18 #[allow(deprecated)]
19 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20 where
21 D: serde::Deserializer<'de>,
22 {
23 const FIELDS: &[&str] = &[
24 "BLOOM_FILTER_UNSPECIFIED",
25 "SSTABLE",
26 "BLOCKED",
27 ];
28
29 struct GeneratedVisitor;
30
31 impl serde::de::Visitor<'_> for GeneratedVisitor {
32 type Value = BloomFilterType;
33
34 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
35 write!(formatter, "expected one of: {:?}", &FIELDS)
36 }
37
38 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
39 where
40 E: serde::de::Error,
41 {
42 i32::try_from(v)
43 .ok()
44 .and_then(|x| x.try_into().ok())
45 .ok_or_else(|| {
46 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
47 })
48 }
49
50 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
51 where
52 E: serde::de::Error,
53 {
54 i32::try_from(v)
55 .ok()
56 .and_then(|x| x.try_into().ok())
57 .ok_or_else(|| {
58 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
59 })
60 }
61
62 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
63 where
64 E: serde::de::Error,
65 {
66 match value {
67 "BLOOM_FILTER_UNSPECIFIED" => Ok(BloomFilterType::BloomFilterUnspecified),
68 "SSTABLE" => Ok(BloomFilterType::Sstable),
69 "BLOCKED" => Ok(BloomFilterType::Blocked),
70 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
71 }
72 }
73 }
74 deserializer.deserialize_any(GeneratedVisitor)
75 }
76}
77impl serde::Serialize for BranchedObject {
78 #[allow(deprecated)]
79 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
80 where
81 S: serde::Serializer,
82 {
83 use serde::ser::SerializeStruct;
84 let mut len = 0;
85 if self.object_id != 0 {
86 len += 1;
87 }
88 if !self.sst_id.is_empty() {
89 len += 1;
90 }
91 if self.compaction_group_id != 0 {
92 len += 1;
93 }
94 let mut struct_ser = serializer.serialize_struct("hummock.BranchedObject", len)?;
95 if self.object_id != 0 {
96 #[allow(clippy::needless_borrow)]
97 #[allow(clippy::needless_borrows_for_generic_args)]
98 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
99 }
100 if !self.sst_id.is_empty() {
101 struct_ser.serialize_field("sstId", &self.sst_id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
102 }
103 if self.compaction_group_id != 0 {
104 #[allow(clippy::needless_borrow)]
105 #[allow(clippy::needless_borrows_for_generic_args)]
106 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
107 }
108 struct_ser.end()
109 }
110}
111impl<'de> serde::Deserialize<'de> for BranchedObject {
112 #[allow(deprecated)]
113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
114 where
115 D: serde::Deserializer<'de>,
116 {
117 const FIELDS: &[&str] = &[
118 "object_id",
119 "objectId",
120 "sst_id",
121 "sstId",
122 "compaction_group_id",
123 "compactionGroupId",
124 ];
125
126 #[allow(clippy::enum_variant_names)]
127 enum GeneratedField {
128 ObjectId,
129 SstId,
130 CompactionGroupId,
131 }
132 impl<'de> serde::Deserialize<'de> for GeneratedField {
133 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
134 where
135 D: serde::Deserializer<'de>,
136 {
137 struct GeneratedVisitor;
138
139 impl serde::de::Visitor<'_> for GeneratedVisitor {
140 type Value = GeneratedField;
141
142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
143 write!(formatter, "expected one of: {:?}", &FIELDS)
144 }
145
146 #[allow(unused_variables)]
147 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
148 where
149 E: serde::de::Error,
150 {
151 match value {
152 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
153 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
154 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
156 }
157 }
158 }
159 deserializer.deserialize_identifier(GeneratedVisitor)
160 }
161 }
162 struct GeneratedVisitor;
163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
164 type Value = BranchedObject;
165
166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
167 formatter.write_str("struct hummock.BranchedObject")
168 }
169
170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BranchedObject, V::Error>
171 where
172 V: serde::de::MapAccess<'de>,
173 {
174 let mut object_id__ = None;
175 let mut sst_id__ = None;
176 let mut compaction_group_id__ = None;
177 while let Some(k) = map_.next_key()? {
178 match k {
179 GeneratedField::ObjectId => {
180 if object_id__.is_some() {
181 return Err(serde::de::Error::duplicate_field("objectId"));
182 }
183 object_id__ =
184 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
185 ;
186 }
187 GeneratedField::SstId => {
188 if sst_id__.is_some() {
189 return Err(serde::de::Error::duplicate_field("sstId"));
190 }
191 sst_id__ =
192 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
193 .into_iter().map(|x| x.0).collect())
194 ;
195 }
196 GeneratedField::CompactionGroupId => {
197 if compaction_group_id__.is_some() {
198 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
199 }
200 compaction_group_id__ =
201 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
202 ;
203 }
204 }
205 }
206 Ok(BranchedObject {
207 object_id: object_id__.unwrap_or_default(),
208 sst_id: sst_id__.unwrap_or_default(),
209 compaction_group_id: compaction_group_id__.unwrap_or_default(),
210 })
211 }
212 }
213 deserializer.deserialize_struct("hummock.BranchedObject", FIELDS, GeneratedVisitor)
214 }
215}
216impl serde::Serialize for CancelCompactTask {
217 #[allow(deprecated)]
218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
219 where
220 S: serde::Serializer,
221 {
222 use serde::ser::SerializeStruct;
223 let mut len = 0;
224 if self.context_id != 0 {
225 len += 1;
226 }
227 if self.task_id != 0 {
228 len += 1;
229 }
230 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTask", len)?;
231 if self.context_id != 0 {
232 struct_ser.serialize_field("contextId", &self.context_id)?;
233 }
234 if self.task_id != 0 {
235 #[allow(clippy::needless_borrow)]
236 #[allow(clippy::needless_borrows_for_generic_args)]
237 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
238 }
239 struct_ser.end()
240 }
241}
242impl<'de> serde::Deserialize<'de> for CancelCompactTask {
243 #[allow(deprecated)]
244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
245 where
246 D: serde::Deserializer<'de>,
247 {
248 const FIELDS: &[&str] = &[
249 "context_id",
250 "contextId",
251 "task_id",
252 "taskId",
253 ];
254
255 #[allow(clippy::enum_variant_names)]
256 enum GeneratedField {
257 ContextId,
258 TaskId,
259 }
260 impl<'de> serde::Deserialize<'de> for GeneratedField {
261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
262 where
263 D: serde::Deserializer<'de>,
264 {
265 struct GeneratedVisitor;
266
267 impl serde::de::Visitor<'_> for GeneratedVisitor {
268 type Value = GeneratedField;
269
270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
271 write!(formatter, "expected one of: {:?}", &FIELDS)
272 }
273
274 #[allow(unused_variables)]
275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
276 where
277 E: serde::de::Error,
278 {
279 match value {
280 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
281 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
283 }
284 }
285 }
286 deserializer.deserialize_identifier(GeneratedVisitor)
287 }
288 }
289 struct GeneratedVisitor;
290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
291 type Value = CancelCompactTask;
292
293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
294 formatter.write_str("struct hummock.CancelCompactTask")
295 }
296
297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTask, V::Error>
298 where
299 V: serde::de::MapAccess<'de>,
300 {
301 let mut context_id__ = None;
302 let mut task_id__ = None;
303 while let Some(k) = map_.next_key()? {
304 match k {
305 GeneratedField::ContextId => {
306 if context_id__.is_some() {
307 return Err(serde::de::Error::duplicate_field("contextId"));
308 }
309 context_id__ =
310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
311 ;
312 }
313 GeneratedField::TaskId => {
314 if task_id__.is_some() {
315 return Err(serde::de::Error::duplicate_field("taskId"));
316 }
317 task_id__ =
318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
319 ;
320 }
321 }
322 }
323 Ok(CancelCompactTask {
324 context_id: context_id__.unwrap_or_default(),
325 task_id: task_id__.unwrap_or_default(),
326 })
327 }
328 }
329 deserializer.deserialize_struct("hummock.CancelCompactTask", FIELDS, GeneratedVisitor)
330 }
331}
332impl serde::Serialize for CancelCompactTaskRequest {
333 #[allow(deprecated)]
334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
335 where
336 S: serde::Serializer,
337 {
338 use serde::ser::SerializeStruct;
339 let mut len = 0;
340 if self.task_id != 0 {
341 len += 1;
342 }
343 if self.task_status != 0 {
344 len += 1;
345 }
346 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskRequest", len)?;
347 if self.task_id != 0 {
348 #[allow(clippy::needless_borrow)]
349 #[allow(clippy::needless_borrows_for_generic_args)]
350 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
351 }
352 if self.task_status != 0 {
353 let v = compact_task::TaskStatus::try_from(self.task_status)
354 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
355 struct_ser.serialize_field("taskStatus", &v)?;
356 }
357 struct_ser.end()
358 }
359}
360impl<'de> serde::Deserialize<'de> for CancelCompactTaskRequest {
361 #[allow(deprecated)]
362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
363 where
364 D: serde::Deserializer<'de>,
365 {
366 const FIELDS: &[&str] = &[
367 "task_id",
368 "taskId",
369 "task_status",
370 "taskStatus",
371 ];
372
373 #[allow(clippy::enum_variant_names)]
374 enum GeneratedField {
375 TaskId,
376 TaskStatus,
377 }
378 impl<'de> serde::Deserialize<'de> for GeneratedField {
379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
380 where
381 D: serde::Deserializer<'de>,
382 {
383 struct GeneratedVisitor;
384
385 impl serde::de::Visitor<'_> for GeneratedVisitor {
386 type Value = GeneratedField;
387
388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
389 write!(formatter, "expected one of: {:?}", &FIELDS)
390 }
391
392 #[allow(unused_variables)]
393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
394 where
395 E: serde::de::Error,
396 {
397 match value {
398 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
399 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
400 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
401 }
402 }
403 }
404 deserializer.deserialize_identifier(GeneratedVisitor)
405 }
406 }
407 struct GeneratedVisitor;
408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
409 type Value = CancelCompactTaskRequest;
410
411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
412 formatter.write_str("struct hummock.CancelCompactTaskRequest")
413 }
414
415 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskRequest, V::Error>
416 where
417 V: serde::de::MapAccess<'de>,
418 {
419 let mut task_id__ = None;
420 let mut task_status__ = None;
421 while let Some(k) = map_.next_key()? {
422 match k {
423 GeneratedField::TaskId => {
424 if task_id__.is_some() {
425 return Err(serde::de::Error::duplicate_field("taskId"));
426 }
427 task_id__ =
428 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
429 ;
430 }
431 GeneratedField::TaskStatus => {
432 if task_status__.is_some() {
433 return Err(serde::de::Error::duplicate_field("taskStatus"));
434 }
435 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
436 }
437 }
438 }
439 Ok(CancelCompactTaskRequest {
440 task_id: task_id__.unwrap_or_default(),
441 task_status: task_status__.unwrap_or_default(),
442 })
443 }
444 }
445 deserializer.deserialize_struct("hummock.CancelCompactTaskRequest", FIELDS, GeneratedVisitor)
446 }
447}
448impl serde::Serialize for CancelCompactTaskResponse {
449 #[allow(deprecated)]
450 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
451 where
452 S: serde::Serializer,
453 {
454 use serde::ser::SerializeStruct;
455 let mut len = 0;
456 if self.ret {
457 len += 1;
458 }
459 let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskResponse", len)?;
460 if self.ret {
461 struct_ser.serialize_field("ret", &self.ret)?;
462 }
463 struct_ser.end()
464 }
465}
466impl<'de> serde::Deserialize<'de> for CancelCompactTaskResponse {
467 #[allow(deprecated)]
468 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
469 where
470 D: serde::Deserializer<'de>,
471 {
472 const FIELDS: &[&str] = &[
473 "ret",
474 ];
475
476 #[allow(clippy::enum_variant_names)]
477 enum GeneratedField {
478 Ret,
479 }
480 impl<'de> serde::Deserialize<'de> for GeneratedField {
481 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
482 where
483 D: serde::Deserializer<'de>,
484 {
485 struct GeneratedVisitor;
486
487 impl serde::de::Visitor<'_> for GeneratedVisitor {
488 type Value = GeneratedField;
489
490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
491 write!(formatter, "expected one of: {:?}", &FIELDS)
492 }
493
494 #[allow(unused_variables)]
495 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
496 where
497 E: serde::de::Error,
498 {
499 match value {
500 "ret" => Ok(GeneratedField::Ret),
501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
502 }
503 }
504 }
505 deserializer.deserialize_identifier(GeneratedVisitor)
506 }
507 }
508 struct GeneratedVisitor;
509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
510 type Value = CancelCompactTaskResponse;
511
512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
513 formatter.write_str("struct hummock.CancelCompactTaskResponse")
514 }
515
516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskResponse, V::Error>
517 where
518 V: serde::de::MapAccess<'de>,
519 {
520 let mut ret__ = None;
521 while let Some(k) = map_.next_key()? {
522 match k {
523 GeneratedField::Ret => {
524 if ret__.is_some() {
525 return Err(serde::de::Error::duplicate_field("ret"));
526 }
527 ret__ = Some(map_.next_value()?);
528 }
529 }
530 }
531 Ok(CancelCompactTaskResponse {
532 ret: ret__.unwrap_or_default(),
533 })
534 }
535 }
536 deserializer.deserialize_struct("hummock.CancelCompactTaskResponse", FIELDS, GeneratedVisitor)
537 }
538}
539impl serde::Serialize for CheckpointCompressionAlgorithm {
540 #[allow(deprecated)]
541 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
542 where
543 S: serde::Serializer,
544 {
545 let variant = match self {
546 Self::CheckpointCompressionUnspecified => "CHECKPOINT_COMPRESSION_UNSPECIFIED",
547 Self::CheckpointCompressionZstd => "CHECKPOINT_COMPRESSION_ZSTD",
548 Self::CheckpointCompressionLz4 => "CHECKPOINT_COMPRESSION_LZ4",
549 };
550 serializer.serialize_str(variant)
551 }
552}
553impl<'de> serde::Deserialize<'de> for CheckpointCompressionAlgorithm {
554 #[allow(deprecated)]
555 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
556 where
557 D: serde::Deserializer<'de>,
558 {
559 const FIELDS: &[&str] = &[
560 "CHECKPOINT_COMPRESSION_UNSPECIFIED",
561 "CHECKPOINT_COMPRESSION_ZSTD",
562 "CHECKPOINT_COMPRESSION_LZ4",
563 ];
564
565 struct GeneratedVisitor;
566
567 impl serde::de::Visitor<'_> for GeneratedVisitor {
568 type Value = CheckpointCompressionAlgorithm;
569
570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
571 write!(formatter, "expected one of: {:?}", &FIELDS)
572 }
573
574 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
575 where
576 E: serde::de::Error,
577 {
578 i32::try_from(v)
579 .ok()
580 .and_then(|x| x.try_into().ok())
581 .ok_or_else(|| {
582 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
583 })
584 }
585
586 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
587 where
588 E: serde::de::Error,
589 {
590 i32::try_from(v)
591 .ok()
592 .and_then(|x| x.try_into().ok())
593 .ok_or_else(|| {
594 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
595 })
596 }
597
598 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
599 where
600 E: serde::de::Error,
601 {
602 match value {
603 "CHECKPOINT_COMPRESSION_UNSPECIFIED" => Ok(CheckpointCompressionAlgorithm::CheckpointCompressionUnspecified),
604 "CHECKPOINT_COMPRESSION_ZSTD" => Ok(CheckpointCompressionAlgorithm::CheckpointCompressionZstd),
605 "CHECKPOINT_COMPRESSION_LZ4" => Ok(CheckpointCompressionAlgorithm::CheckpointCompressionLz4),
606 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
607 }
608 }
609 }
610 deserializer.deserialize_any(GeneratedVisitor)
611 }
612}
613impl serde::Serialize for CompactStatus {
614 #[allow(deprecated)]
615 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
616 where
617 S: serde::Serializer,
618 {
619 use serde::ser::SerializeStruct;
620 let mut len = 0;
621 if self.compaction_group_id != 0 {
622 len += 1;
623 }
624 if !self.level_handlers.is_empty() {
625 len += 1;
626 }
627 let mut struct_ser = serializer.serialize_struct("hummock.CompactStatus", len)?;
628 if self.compaction_group_id != 0 {
629 #[allow(clippy::needless_borrow)]
630 #[allow(clippy::needless_borrows_for_generic_args)]
631 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
632 }
633 if !self.level_handlers.is_empty() {
634 struct_ser.serialize_field("levelHandlers", &self.level_handlers)?;
635 }
636 struct_ser.end()
637 }
638}
639impl<'de> serde::Deserialize<'de> for CompactStatus {
640 #[allow(deprecated)]
641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
642 where
643 D: serde::Deserializer<'de>,
644 {
645 const FIELDS: &[&str] = &[
646 "compaction_group_id",
647 "compactionGroupId",
648 "level_handlers",
649 "levelHandlers",
650 ];
651
652 #[allow(clippy::enum_variant_names)]
653 enum GeneratedField {
654 CompactionGroupId,
655 LevelHandlers,
656 }
657 impl<'de> serde::Deserialize<'de> for GeneratedField {
658 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
659 where
660 D: serde::Deserializer<'de>,
661 {
662 struct GeneratedVisitor;
663
664 impl serde::de::Visitor<'_> for GeneratedVisitor {
665 type Value = GeneratedField;
666
667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
668 write!(formatter, "expected one of: {:?}", &FIELDS)
669 }
670
671 #[allow(unused_variables)]
672 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
673 where
674 E: serde::de::Error,
675 {
676 match value {
677 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
678 "levelHandlers" | "level_handlers" => Ok(GeneratedField::LevelHandlers),
679 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
680 }
681 }
682 }
683 deserializer.deserialize_identifier(GeneratedVisitor)
684 }
685 }
686 struct GeneratedVisitor;
687 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
688 type Value = CompactStatus;
689
690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
691 formatter.write_str("struct hummock.CompactStatus")
692 }
693
694 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactStatus, V::Error>
695 where
696 V: serde::de::MapAccess<'de>,
697 {
698 let mut compaction_group_id__ = None;
699 let mut level_handlers__ = None;
700 while let Some(k) = map_.next_key()? {
701 match k {
702 GeneratedField::CompactionGroupId => {
703 if compaction_group_id__.is_some() {
704 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
705 }
706 compaction_group_id__ =
707 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
708 ;
709 }
710 GeneratedField::LevelHandlers => {
711 if level_handlers__.is_some() {
712 return Err(serde::de::Error::duplicate_field("levelHandlers"));
713 }
714 level_handlers__ = Some(map_.next_value()?);
715 }
716 }
717 }
718 Ok(CompactStatus {
719 compaction_group_id: compaction_group_id__.unwrap_or_default(),
720 level_handlers: level_handlers__.unwrap_or_default(),
721 })
722 }
723 }
724 deserializer.deserialize_struct("hummock.CompactStatus", FIELDS, GeneratedVisitor)
725 }
726}
727impl serde::Serialize for CompactTask {
728 #[allow(deprecated)]
729 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
730 where
731 S: serde::Serializer,
732 {
733 use serde::ser::SerializeStruct;
734 let mut len = 0;
735 if !self.input_ssts.is_empty() {
736 len += 1;
737 }
738 if !self.splits.is_empty() {
739 len += 1;
740 }
741 if !self.sorted_output_ssts.is_empty() {
742 len += 1;
743 }
744 if self.task_id != 0 {
745 len += 1;
746 }
747 if self.target_level != 0 {
748 len += 1;
749 }
750 if self.gc_delete_keys {
751 len += 1;
752 }
753 if self.base_level != 0 {
754 len += 1;
755 }
756 if self.task_status != 0 {
757 len += 1;
758 }
759 if self.compaction_group_id != 0 {
760 len += 1;
761 }
762 if !self.existing_table_ids.is_empty() {
763 len += 1;
764 }
765 if self.compression_algorithm != 0 {
766 len += 1;
767 }
768 if self.target_file_size != 0 {
769 len += 1;
770 }
771 if self.compaction_filter_mask != 0 {
772 len += 1;
773 }
774 if !self.table_options.is_empty() {
775 len += 1;
776 }
777 if self.current_epoch_time != 0 {
778 len += 1;
779 }
780 if self.target_sub_level_id != 0 {
781 len += 1;
782 }
783 if self.task_type != 0 {
784 len += 1;
785 }
786 if self.split_by_state_table {
787 len += 1;
788 }
789 if self.split_weight_by_vnode != 0 {
790 len += 1;
791 }
792 if !self.table_vnode_partition.is_empty() {
793 len += 1;
794 }
795 if !self.table_watermarks.is_empty() {
796 len += 1;
797 }
798 if !self.table_schemas.is_empty() {
799 len += 1;
800 }
801 if self.max_sub_compaction != 0 {
802 len += 1;
803 }
804 if self.compaction_group_version_id != 0 {
805 len += 1;
806 }
807 if self.max_kv_count_for_xor16.is_some() {
808 len += 1;
809 }
810 if self.max_vnode_key_range_bytes.is_some() {
811 len += 1;
812 }
813 if self.sstable_filter_kind != 0 {
814 len += 1;
815 }
816 if self.sstable_filter_layout != 0 {
817 len += 1;
818 }
819 let mut struct_ser = serializer.serialize_struct("hummock.CompactTask", len)?;
820 if !self.input_ssts.is_empty() {
821 struct_ser.serialize_field("inputSsts", &self.input_ssts)?;
822 }
823 if !self.splits.is_empty() {
824 struct_ser.serialize_field("splits", &self.splits)?;
825 }
826 if !self.sorted_output_ssts.is_empty() {
827 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
828 }
829 if self.task_id != 0 {
830 #[allow(clippy::needless_borrow)]
831 #[allow(clippy::needless_borrows_for_generic_args)]
832 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
833 }
834 if self.target_level != 0 {
835 struct_ser.serialize_field("targetLevel", &self.target_level)?;
836 }
837 if self.gc_delete_keys {
838 struct_ser.serialize_field("gcDeleteKeys", &self.gc_delete_keys)?;
839 }
840 if self.base_level != 0 {
841 struct_ser.serialize_field("baseLevel", &self.base_level)?;
842 }
843 if self.task_status != 0 {
844 let v = compact_task::TaskStatus::try_from(self.task_status)
845 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
846 struct_ser.serialize_field("taskStatus", &v)?;
847 }
848 if self.compaction_group_id != 0 {
849 #[allow(clippy::needless_borrow)]
850 #[allow(clippy::needless_borrows_for_generic_args)]
851 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
852 }
853 if !self.existing_table_ids.is_empty() {
854 struct_ser.serialize_field("existingTableIds", &self.existing_table_ids)?;
855 }
856 if self.compression_algorithm != 0 {
857 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
858 }
859 if self.target_file_size != 0 {
860 #[allow(clippy::needless_borrow)]
861 #[allow(clippy::needless_borrows_for_generic_args)]
862 struct_ser.serialize_field("targetFileSize", ToString::to_string(&self.target_file_size).as_str())?;
863 }
864 if self.compaction_filter_mask != 0 {
865 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
866 }
867 if !self.table_options.is_empty() {
868 struct_ser.serialize_field("tableOptions", &self.table_options)?;
869 }
870 if self.current_epoch_time != 0 {
871 #[allow(clippy::needless_borrow)]
872 #[allow(clippy::needless_borrows_for_generic_args)]
873 struct_ser.serialize_field("currentEpochTime", ToString::to_string(&self.current_epoch_time).as_str())?;
874 }
875 if self.target_sub_level_id != 0 {
876 #[allow(clippy::needless_borrow)]
877 #[allow(clippy::needless_borrows_for_generic_args)]
878 struct_ser.serialize_field("targetSubLevelId", ToString::to_string(&self.target_sub_level_id).as_str())?;
879 }
880 if self.task_type != 0 {
881 let v = compact_task::TaskType::try_from(self.task_type)
882 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_type)))?;
883 struct_ser.serialize_field("taskType", &v)?;
884 }
885 if self.split_by_state_table {
886 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
887 }
888 if self.split_weight_by_vnode != 0 {
889 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
890 }
891 if !self.table_vnode_partition.is_empty() {
892 struct_ser.serialize_field("tableVnodePartition", &self.table_vnode_partition)?;
893 }
894 if !self.table_watermarks.is_empty() {
895 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
896 }
897 if !self.table_schemas.is_empty() {
898 struct_ser.serialize_field("tableSchemas", &self.table_schemas)?;
899 }
900 if self.max_sub_compaction != 0 {
901 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
902 }
903 if self.compaction_group_version_id != 0 {
904 #[allow(clippy::needless_borrow)]
905 #[allow(clippy::needless_borrows_for_generic_args)]
906 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
907 }
908 if let Some(v) = self.max_kv_count_for_xor16.as_ref() {
909 #[allow(clippy::needless_borrow)]
910 #[allow(clippy::needless_borrows_for_generic_args)]
911 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
912 }
913 if let Some(v) = self.max_vnode_key_range_bytes.as_ref() {
914 #[allow(clippy::needless_borrow)]
915 #[allow(clippy::needless_borrows_for_generic_args)]
916 struct_ser.serialize_field("maxVnodeKeyRangeBytes", ToString::to_string(&v).as_str())?;
917 }
918 if self.sstable_filter_kind != 0 {
919 let v = SstableFilterType::try_from(self.sstable_filter_kind)
920 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sstable_filter_kind)))?;
921 struct_ser.serialize_field("sstableFilterKind", &v)?;
922 }
923 if self.sstable_filter_layout != 0 {
924 let v = SstableFilterLayout::try_from(self.sstable_filter_layout)
925 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sstable_filter_layout)))?;
926 struct_ser.serialize_field("sstableFilterLayout", &v)?;
927 }
928 struct_ser.end()
929 }
930}
931impl<'de> serde::Deserialize<'de> for CompactTask {
932 #[allow(deprecated)]
933 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
934 where
935 D: serde::Deserializer<'de>,
936 {
937 const FIELDS: &[&str] = &[
938 "input_ssts",
939 "inputSsts",
940 "splits",
941 "sorted_output_ssts",
942 "sortedOutputSsts",
943 "task_id",
944 "taskId",
945 "target_level",
946 "targetLevel",
947 "gc_delete_keys",
948 "gcDeleteKeys",
949 "base_level",
950 "baseLevel",
951 "task_status",
952 "taskStatus",
953 "compaction_group_id",
954 "compactionGroupId",
955 "existing_table_ids",
956 "existingTableIds",
957 "compression_algorithm",
958 "compressionAlgorithm",
959 "target_file_size",
960 "targetFileSize",
961 "compaction_filter_mask",
962 "compactionFilterMask",
963 "table_options",
964 "tableOptions",
965 "current_epoch_time",
966 "currentEpochTime",
967 "target_sub_level_id",
968 "targetSubLevelId",
969 "task_type",
970 "taskType",
971 "split_by_state_table",
972 "splitByStateTable",
973 "split_weight_by_vnode",
974 "splitWeightByVnode",
975 "table_vnode_partition",
976 "tableVnodePartition",
977 "table_watermarks",
978 "tableWatermarks",
979 "table_schemas",
980 "tableSchemas",
981 "max_sub_compaction",
982 "maxSubCompaction",
983 "compaction_group_version_id",
984 "compactionGroupVersionId",
985 "max_kv_count_for_xor16",
986 "maxKvCountForXor16",
987 "max_vnode_key_range_bytes",
988 "maxVnodeKeyRangeBytes",
989 "sstable_filter_kind",
990 "sstableFilterKind",
991 "sstable_filter_layout",
992 "sstableFilterLayout",
993 ];
994
995 #[allow(clippy::enum_variant_names)]
996 enum GeneratedField {
997 InputSsts,
998 Splits,
999 SortedOutputSsts,
1000 TaskId,
1001 TargetLevel,
1002 GcDeleteKeys,
1003 BaseLevel,
1004 TaskStatus,
1005 CompactionGroupId,
1006 ExistingTableIds,
1007 CompressionAlgorithm,
1008 TargetFileSize,
1009 CompactionFilterMask,
1010 TableOptions,
1011 CurrentEpochTime,
1012 TargetSubLevelId,
1013 TaskType,
1014 SplitByStateTable,
1015 SplitWeightByVnode,
1016 TableVnodePartition,
1017 TableWatermarks,
1018 TableSchemas,
1019 MaxSubCompaction,
1020 CompactionGroupVersionId,
1021 MaxKvCountForXor16,
1022 MaxVnodeKeyRangeBytes,
1023 SstableFilterKind,
1024 SstableFilterLayout,
1025 }
1026 impl<'de> serde::Deserialize<'de> for GeneratedField {
1027 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1028 where
1029 D: serde::Deserializer<'de>,
1030 {
1031 struct GeneratedVisitor;
1032
1033 impl serde::de::Visitor<'_> for GeneratedVisitor {
1034 type Value = GeneratedField;
1035
1036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1037 write!(formatter, "expected one of: {:?}", &FIELDS)
1038 }
1039
1040 #[allow(unused_variables)]
1041 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1042 where
1043 E: serde::de::Error,
1044 {
1045 match value {
1046 "inputSsts" | "input_ssts" => Ok(GeneratedField::InputSsts),
1047 "splits" => Ok(GeneratedField::Splits),
1048 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
1049 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1050 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
1051 "gcDeleteKeys" | "gc_delete_keys" => Ok(GeneratedField::GcDeleteKeys),
1052 "baseLevel" | "base_level" => Ok(GeneratedField::BaseLevel),
1053 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
1054 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1055 "existingTableIds" | "existing_table_ids" => Ok(GeneratedField::ExistingTableIds),
1056 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
1057 "targetFileSize" | "target_file_size" => Ok(GeneratedField::TargetFileSize),
1058 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
1059 "tableOptions" | "table_options" => Ok(GeneratedField::TableOptions),
1060 "currentEpochTime" | "current_epoch_time" => Ok(GeneratedField::CurrentEpochTime),
1061 "targetSubLevelId" | "target_sub_level_id" => Ok(GeneratedField::TargetSubLevelId),
1062 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
1063 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
1064 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
1065 "tableVnodePartition" | "table_vnode_partition" => Ok(GeneratedField::TableVnodePartition),
1066 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
1067 "tableSchemas" | "table_schemas" => Ok(GeneratedField::TableSchemas),
1068 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
1069 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
1070 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
1071 "maxVnodeKeyRangeBytes" | "max_vnode_key_range_bytes" => Ok(GeneratedField::MaxVnodeKeyRangeBytes),
1072 "sstableFilterKind" | "sstable_filter_kind" => Ok(GeneratedField::SstableFilterKind),
1073 "sstableFilterLayout" | "sstable_filter_layout" => Ok(GeneratedField::SstableFilterLayout),
1074 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1075 }
1076 }
1077 }
1078 deserializer.deserialize_identifier(GeneratedVisitor)
1079 }
1080 }
1081 struct GeneratedVisitor;
1082 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1083 type Value = CompactTask;
1084
1085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1086 formatter.write_str("struct hummock.CompactTask")
1087 }
1088
1089 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTask, V::Error>
1090 where
1091 V: serde::de::MapAccess<'de>,
1092 {
1093 let mut input_ssts__ = None;
1094 let mut splits__ = None;
1095 let mut sorted_output_ssts__ = None;
1096 let mut task_id__ = None;
1097 let mut target_level__ = None;
1098 let mut gc_delete_keys__ = None;
1099 let mut base_level__ = None;
1100 let mut task_status__ = None;
1101 let mut compaction_group_id__ = None;
1102 let mut existing_table_ids__ = None;
1103 let mut compression_algorithm__ = None;
1104 let mut target_file_size__ = None;
1105 let mut compaction_filter_mask__ = None;
1106 let mut table_options__ = None;
1107 let mut current_epoch_time__ = None;
1108 let mut target_sub_level_id__ = None;
1109 let mut task_type__ = None;
1110 let mut split_by_state_table__ = None;
1111 let mut split_weight_by_vnode__ = None;
1112 let mut table_vnode_partition__ = None;
1113 let mut table_watermarks__ = None;
1114 let mut table_schemas__ = None;
1115 let mut max_sub_compaction__ = None;
1116 let mut compaction_group_version_id__ = None;
1117 let mut max_kv_count_for_xor16__ = None;
1118 let mut max_vnode_key_range_bytes__ = None;
1119 let mut sstable_filter_kind__ = None;
1120 let mut sstable_filter_layout__ = None;
1121 while let Some(k) = map_.next_key()? {
1122 match k {
1123 GeneratedField::InputSsts => {
1124 if input_ssts__.is_some() {
1125 return Err(serde::de::Error::duplicate_field("inputSsts"));
1126 }
1127 input_ssts__ = Some(map_.next_value()?);
1128 }
1129 GeneratedField::Splits => {
1130 if splits__.is_some() {
1131 return Err(serde::de::Error::duplicate_field("splits"));
1132 }
1133 splits__ = Some(map_.next_value()?);
1134 }
1135 GeneratedField::SortedOutputSsts => {
1136 if sorted_output_ssts__.is_some() {
1137 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
1138 }
1139 sorted_output_ssts__ = Some(map_.next_value()?);
1140 }
1141 GeneratedField::TaskId => {
1142 if task_id__.is_some() {
1143 return Err(serde::de::Error::duplicate_field("taskId"));
1144 }
1145 task_id__ =
1146 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1147 ;
1148 }
1149 GeneratedField::TargetLevel => {
1150 if target_level__.is_some() {
1151 return Err(serde::de::Error::duplicate_field("targetLevel"));
1152 }
1153 target_level__ =
1154 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1155 ;
1156 }
1157 GeneratedField::GcDeleteKeys => {
1158 if gc_delete_keys__.is_some() {
1159 return Err(serde::de::Error::duplicate_field("gcDeleteKeys"));
1160 }
1161 gc_delete_keys__ = Some(map_.next_value()?);
1162 }
1163 GeneratedField::BaseLevel => {
1164 if base_level__.is_some() {
1165 return Err(serde::de::Error::duplicate_field("baseLevel"));
1166 }
1167 base_level__ =
1168 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1169 ;
1170 }
1171 GeneratedField::TaskStatus => {
1172 if task_status__.is_some() {
1173 return Err(serde::de::Error::duplicate_field("taskStatus"));
1174 }
1175 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
1176 }
1177 GeneratedField::CompactionGroupId => {
1178 if compaction_group_id__.is_some() {
1179 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1180 }
1181 compaction_group_id__ =
1182 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1183 ;
1184 }
1185 GeneratedField::ExistingTableIds => {
1186 if existing_table_ids__.is_some() {
1187 return Err(serde::de::Error::duplicate_field("existingTableIds"));
1188 }
1189 existing_table_ids__ =
1190 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1191 .into_iter().map(|x| x.0).collect())
1192 ;
1193 }
1194 GeneratedField::CompressionAlgorithm => {
1195 if compression_algorithm__.is_some() {
1196 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
1197 }
1198 compression_algorithm__ =
1199 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1200 ;
1201 }
1202 GeneratedField::TargetFileSize => {
1203 if target_file_size__.is_some() {
1204 return Err(serde::de::Error::duplicate_field("targetFileSize"));
1205 }
1206 target_file_size__ =
1207 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1208 ;
1209 }
1210 GeneratedField::CompactionFilterMask => {
1211 if compaction_filter_mask__.is_some() {
1212 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
1213 }
1214 compaction_filter_mask__ =
1215 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1216 ;
1217 }
1218 GeneratedField::TableOptions => {
1219 if table_options__.is_some() {
1220 return Err(serde::de::Error::duplicate_field("tableOptions"));
1221 }
1222 table_options__ = Some(
1223 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1224 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1225 );
1226 }
1227 GeneratedField::CurrentEpochTime => {
1228 if current_epoch_time__.is_some() {
1229 return Err(serde::de::Error::duplicate_field("currentEpochTime"));
1230 }
1231 current_epoch_time__ =
1232 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1233 ;
1234 }
1235 GeneratedField::TargetSubLevelId => {
1236 if target_sub_level_id__.is_some() {
1237 return Err(serde::de::Error::duplicate_field("targetSubLevelId"));
1238 }
1239 target_sub_level_id__ =
1240 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1241 ;
1242 }
1243 GeneratedField::TaskType => {
1244 if task_type__.is_some() {
1245 return Err(serde::de::Error::duplicate_field("taskType"));
1246 }
1247 task_type__ = Some(map_.next_value::<compact_task::TaskType>()? as i32);
1248 }
1249 GeneratedField::SplitByStateTable => {
1250 if split_by_state_table__.is_some() {
1251 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
1252 }
1253 split_by_state_table__ = Some(map_.next_value()?);
1254 }
1255 GeneratedField::SplitWeightByVnode => {
1256 if split_weight_by_vnode__.is_some() {
1257 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
1258 }
1259 split_weight_by_vnode__ =
1260 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1261 ;
1262 }
1263 GeneratedField::TableVnodePartition => {
1264 if table_vnode_partition__.is_some() {
1265 return Err(serde::de::Error::duplicate_field("tableVnodePartition"));
1266 }
1267 table_vnode_partition__ = Some(
1268 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
1269 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
1270 );
1271 }
1272 GeneratedField::TableWatermarks => {
1273 if table_watermarks__.is_some() {
1274 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
1275 }
1276 table_watermarks__ = Some(
1277 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1278 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1279 );
1280 }
1281 GeneratedField::TableSchemas => {
1282 if table_schemas__.is_some() {
1283 return Err(serde::de::Error::duplicate_field("tableSchemas"));
1284 }
1285 table_schemas__ = Some(
1286 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1287 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1288 );
1289 }
1290 GeneratedField::MaxSubCompaction => {
1291 if max_sub_compaction__.is_some() {
1292 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
1293 }
1294 max_sub_compaction__ =
1295 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1296 ;
1297 }
1298 GeneratedField::CompactionGroupVersionId => {
1299 if compaction_group_version_id__.is_some() {
1300 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
1301 }
1302 compaction_group_version_id__ =
1303 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1304 ;
1305 }
1306 GeneratedField::MaxKvCountForXor16 => {
1307 if max_kv_count_for_xor16__.is_some() {
1308 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
1309 }
1310 max_kv_count_for_xor16__ =
1311 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1312 ;
1313 }
1314 GeneratedField::MaxVnodeKeyRangeBytes => {
1315 if max_vnode_key_range_bytes__.is_some() {
1316 return Err(serde::de::Error::duplicate_field("maxVnodeKeyRangeBytes"));
1317 }
1318 max_vnode_key_range_bytes__ =
1319 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1320 ;
1321 }
1322 GeneratedField::SstableFilterKind => {
1323 if sstable_filter_kind__.is_some() {
1324 return Err(serde::de::Error::duplicate_field("sstableFilterKind"));
1325 }
1326 sstable_filter_kind__ = Some(map_.next_value::<SstableFilterType>()? as i32);
1327 }
1328 GeneratedField::SstableFilterLayout => {
1329 if sstable_filter_layout__.is_some() {
1330 return Err(serde::de::Error::duplicate_field("sstableFilterLayout"));
1331 }
1332 sstable_filter_layout__ = Some(map_.next_value::<SstableFilterLayout>()? as i32);
1333 }
1334 }
1335 }
1336 Ok(CompactTask {
1337 input_ssts: input_ssts__.unwrap_or_default(),
1338 splits: splits__.unwrap_or_default(),
1339 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
1340 task_id: task_id__.unwrap_or_default(),
1341 target_level: target_level__.unwrap_or_default(),
1342 gc_delete_keys: gc_delete_keys__.unwrap_or_default(),
1343 base_level: base_level__.unwrap_or_default(),
1344 task_status: task_status__.unwrap_or_default(),
1345 compaction_group_id: compaction_group_id__.unwrap_or_default(),
1346 existing_table_ids: existing_table_ids__.unwrap_or_default(),
1347 compression_algorithm: compression_algorithm__.unwrap_or_default(),
1348 target_file_size: target_file_size__.unwrap_or_default(),
1349 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
1350 table_options: table_options__.unwrap_or_default(),
1351 current_epoch_time: current_epoch_time__.unwrap_or_default(),
1352 target_sub_level_id: target_sub_level_id__.unwrap_or_default(),
1353 task_type: task_type__.unwrap_or_default(),
1354 split_by_state_table: split_by_state_table__.unwrap_or_default(),
1355 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
1356 table_vnode_partition: table_vnode_partition__.unwrap_or_default(),
1357 table_watermarks: table_watermarks__.unwrap_or_default(),
1358 table_schemas: table_schemas__.unwrap_or_default(),
1359 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
1360 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
1361 max_kv_count_for_xor16: max_kv_count_for_xor16__,
1362 max_vnode_key_range_bytes: max_vnode_key_range_bytes__,
1363 sstable_filter_kind: sstable_filter_kind__.unwrap_or_default(),
1364 sstable_filter_layout: sstable_filter_layout__.unwrap_or_default(),
1365 })
1366 }
1367 }
1368 deserializer.deserialize_struct("hummock.CompactTask", FIELDS, GeneratedVisitor)
1369 }
1370}
1371impl serde::Serialize for compact_task::TaskStatus {
1372 #[allow(deprecated)]
1373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1374 where
1375 S: serde::Serializer,
1376 {
1377 let variant = match self {
1378 Self::Unspecified => "UNSPECIFIED",
1379 Self::Pending => "PENDING",
1380 Self::Success => "SUCCESS",
1381 Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
1382 Self::NoAvailMemoryResourceCanceled => "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1383 Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
1384 Self::SendFailCanceled => "SEND_FAIL_CANCELED",
1385 Self::ManualCanceled => "MANUAL_CANCELED",
1386 Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
1387 Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
1388 Self::ExecuteFailed => "EXECUTE_FAILED",
1389 Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
1390 Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
1391 Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
1392 Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
1393 Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
1394 Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
1395 Self::ServerlessTableNotFoundCanceled => "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1396 };
1397 serializer.serialize_str(variant)
1398 }
1399}
1400impl<'de> serde::Deserialize<'de> for compact_task::TaskStatus {
1401 #[allow(deprecated)]
1402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1403 where
1404 D: serde::Deserializer<'de>,
1405 {
1406 const FIELDS: &[&str] = &[
1407 "UNSPECIFIED",
1408 "PENDING",
1409 "SUCCESS",
1410 "HEARTBEAT_CANCELED",
1411 "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1412 "ASSIGN_FAIL_CANCELED",
1413 "SEND_FAIL_CANCELED",
1414 "MANUAL_CANCELED",
1415 "INVALID_GROUP_CANCELED",
1416 "INPUT_OUTDATED_CANCELED",
1417 "EXECUTE_FAILED",
1418 "JOIN_HANDLE_FAILED",
1419 "TRACK_SST_OBJECT_ID_FAILED",
1420 "NO_AVAIL_CPU_RESOURCE_CANCELED",
1421 "HEARTBEAT_PROGRESS_CANCELED",
1422 "RETENTION_TIME_REJECTED",
1423 "SERVERLESS_SEND_FAIL_CANCELED",
1424 "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1425 ];
1426
1427 struct GeneratedVisitor;
1428
1429 impl serde::de::Visitor<'_> for GeneratedVisitor {
1430 type Value = compact_task::TaskStatus;
1431
1432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1433 write!(formatter, "expected one of: {:?}", &FIELDS)
1434 }
1435
1436 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1437 where
1438 E: serde::de::Error,
1439 {
1440 i32::try_from(v)
1441 .ok()
1442 .and_then(|x| x.try_into().ok())
1443 .ok_or_else(|| {
1444 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1445 })
1446 }
1447
1448 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1449 where
1450 E: serde::de::Error,
1451 {
1452 i32::try_from(v)
1453 .ok()
1454 .and_then(|x| x.try_into().ok())
1455 .ok_or_else(|| {
1456 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1457 })
1458 }
1459
1460 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1461 where
1462 E: serde::de::Error,
1463 {
1464 match value {
1465 "UNSPECIFIED" => Ok(compact_task::TaskStatus::Unspecified),
1466 "PENDING" => Ok(compact_task::TaskStatus::Pending),
1467 "SUCCESS" => Ok(compact_task::TaskStatus::Success),
1468 "HEARTBEAT_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatCanceled),
1469 "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailMemoryResourceCanceled),
1470 "ASSIGN_FAIL_CANCELED" => Ok(compact_task::TaskStatus::AssignFailCanceled),
1471 "SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::SendFailCanceled),
1472 "MANUAL_CANCELED" => Ok(compact_task::TaskStatus::ManualCanceled),
1473 "INVALID_GROUP_CANCELED" => Ok(compact_task::TaskStatus::InvalidGroupCanceled),
1474 "INPUT_OUTDATED_CANCELED" => Ok(compact_task::TaskStatus::InputOutdatedCanceled),
1475 "EXECUTE_FAILED" => Ok(compact_task::TaskStatus::ExecuteFailed),
1476 "JOIN_HANDLE_FAILED" => Ok(compact_task::TaskStatus::JoinHandleFailed),
1477 "TRACK_SST_OBJECT_ID_FAILED" => Ok(compact_task::TaskStatus::TrackSstObjectIdFailed),
1478 "NO_AVAIL_CPU_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailCpuResourceCanceled),
1479 "HEARTBEAT_PROGRESS_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatProgressCanceled),
1480 "RETENTION_TIME_REJECTED" => Ok(compact_task::TaskStatus::RetentionTimeRejected),
1481 "SERVERLESS_SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::ServerlessSendFailCanceled),
1482 "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => Ok(compact_task::TaskStatus::ServerlessTableNotFoundCanceled),
1483 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1484 }
1485 }
1486 }
1487 deserializer.deserialize_any(GeneratedVisitor)
1488 }
1489}
1490impl serde::Serialize for compact_task::TaskType {
1491 #[allow(deprecated)]
1492 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1493 where
1494 S: serde::Serializer,
1495 {
1496 let variant = match self {
1497 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1498 Self::Dynamic => "DYNAMIC",
1499 Self::SpaceReclaim => "SPACE_RECLAIM",
1500 Self::Manual => "MANUAL",
1501 Self::SharedBuffer => "SHARED_BUFFER",
1502 Self::Ttl => "TTL",
1503 Self::Tombstone => "TOMBSTONE",
1504 Self::Emergency => "EMERGENCY",
1505 Self::VnodeWatermark => "VNODE_WATERMARK",
1506 };
1507 serializer.serialize_str(variant)
1508 }
1509}
1510impl<'de> serde::Deserialize<'de> for compact_task::TaskType {
1511 #[allow(deprecated)]
1512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1513 where
1514 D: serde::Deserializer<'de>,
1515 {
1516 const FIELDS: &[&str] = &[
1517 "TYPE_UNSPECIFIED",
1518 "DYNAMIC",
1519 "SPACE_RECLAIM",
1520 "MANUAL",
1521 "SHARED_BUFFER",
1522 "TTL",
1523 "TOMBSTONE",
1524 "EMERGENCY",
1525 "VNODE_WATERMARK",
1526 ];
1527
1528 struct GeneratedVisitor;
1529
1530 impl serde::de::Visitor<'_> for GeneratedVisitor {
1531 type Value = compact_task::TaskType;
1532
1533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1534 write!(formatter, "expected one of: {:?}", &FIELDS)
1535 }
1536
1537 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1538 where
1539 E: serde::de::Error,
1540 {
1541 i32::try_from(v)
1542 .ok()
1543 .and_then(|x| x.try_into().ok())
1544 .ok_or_else(|| {
1545 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1546 })
1547 }
1548
1549 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1550 where
1551 E: serde::de::Error,
1552 {
1553 i32::try_from(v)
1554 .ok()
1555 .and_then(|x| x.try_into().ok())
1556 .ok_or_else(|| {
1557 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1558 })
1559 }
1560
1561 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1562 where
1563 E: serde::de::Error,
1564 {
1565 match value {
1566 "TYPE_UNSPECIFIED" => Ok(compact_task::TaskType::TypeUnspecified),
1567 "DYNAMIC" => Ok(compact_task::TaskType::Dynamic),
1568 "SPACE_RECLAIM" => Ok(compact_task::TaskType::SpaceReclaim),
1569 "MANUAL" => Ok(compact_task::TaskType::Manual),
1570 "SHARED_BUFFER" => Ok(compact_task::TaskType::SharedBuffer),
1571 "TTL" => Ok(compact_task::TaskType::Ttl),
1572 "TOMBSTONE" => Ok(compact_task::TaskType::Tombstone),
1573 "EMERGENCY" => Ok(compact_task::TaskType::Emergency),
1574 "VNODE_WATERMARK" => Ok(compact_task::TaskType::VnodeWatermark),
1575 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1576 }
1577 }
1578 }
1579 deserializer.deserialize_any(GeneratedVisitor)
1580 }
1581}
1582impl serde::Serialize for CompactTaskAssignment {
1583 #[allow(deprecated)]
1584 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1585 where
1586 S: serde::Serializer,
1587 {
1588 use serde::ser::SerializeStruct;
1589 let mut len = 0;
1590 if self.compact_task.is_some() {
1591 len += 1;
1592 }
1593 if self.context_id != 0 {
1594 len += 1;
1595 }
1596 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskAssignment", len)?;
1597 if let Some(v) = self.compact_task.as_ref() {
1598 struct_ser.serialize_field("compactTask", v)?;
1599 }
1600 if self.context_id != 0 {
1601 struct_ser.serialize_field("contextId", &self.context_id)?;
1602 }
1603 struct_ser.end()
1604 }
1605}
1606impl<'de> serde::Deserialize<'de> for CompactTaskAssignment {
1607 #[allow(deprecated)]
1608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1609 where
1610 D: serde::Deserializer<'de>,
1611 {
1612 const FIELDS: &[&str] = &[
1613 "compact_task",
1614 "compactTask",
1615 "context_id",
1616 "contextId",
1617 ];
1618
1619 #[allow(clippy::enum_variant_names)]
1620 enum GeneratedField {
1621 CompactTask,
1622 ContextId,
1623 }
1624 impl<'de> serde::Deserialize<'de> for GeneratedField {
1625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1626 where
1627 D: serde::Deserializer<'de>,
1628 {
1629 struct GeneratedVisitor;
1630
1631 impl serde::de::Visitor<'_> for GeneratedVisitor {
1632 type Value = GeneratedField;
1633
1634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1635 write!(formatter, "expected one of: {:?}", &FIELDS)
1636 }
1637
1638 #[allow(unused_variables)]
1639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1640 where
1641 E: serde::de::Error,
1642 {
1643 match value {
1644 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
1645 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
1646 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1647 }
1648 }
1649 }
1650 deserializer.deserialize_identifier(GeneratedVisitor)
1651 }
1652 }
1653 struct GeneratedVisitor;
1654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1655 type Value = CompactTaskAssignment;
1656
1657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1658 formatter.write_str("struct hummock.CompactTaskAssignment")
1659 }
1660
1661 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskAssignment, V::Error>
1662 where
1663 V: serde::de::MapAccess<'de>,
1664 {
1665 let mut compact_task__ = None;
1666 let mut context_id__ = None;
1667 while let Some(k) = map_.next_key()? {
1668 match k {
1669 GeneratedField::CompactTask => {
1670 if compact_task__.is_some() {
1671 return Err(serde::de::Error::duplicate_field("compactTask"));
1672 }
1673 compact_task__ = map_.next_value()?;
1674 }
1675 GeneratedField::ContextId => {
1676 if context_id__.is_some() {
1677 return Err(serde::de::Error::duplicate_field("contextId"));
1678 }
1679 context_id__ =
1680 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1681 ;
1682 }
1683 }
1684 }
1685 Ok(CompactTaskAssignment {
1686 compact_task: compact_task__,
1687 context_id: context_id__.unwrap_or_default(),
1688 })
1689 }
1690 }
1691 deserializer.deserialize_struct("hummock.CompactTaskAssignment", FIELDS, GeneratedVisitor)
1692 }
1693}
1694impl serde::Serialize for CompactTaskProgress {
1695 #[allow(deprecated)]
1696 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1697 where
1698 S: serde::Serializer,
1699 {
1700 use serde::ser::SerializeStruct;
1701 let mut len = 0;
1702 if self.task_id != 0 {
1703 len += 1;
1704 }
1705 if self.num_ssts_sealed != 0 {
1706 len += 1;
1707 }
1708 if self.num_ssts_uploaded != 0 {
1709 len += 1;
1710 }
1711 if self.num_progress_key != 0 {
1712 len += 1;
1713 }
1714 if self.num_pending_read_io != 0 {
1715 len += 1;
1716 }
1717 if self.num_pending_write_io != 0 {
1718 len += 1;
1719 }
1720 if self.compaction_group_id.is_some() {
1721 len += 1;
1722 }
1723 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskProgress", len)?;
1724 if self.task_id != 0 {
1725 #[allow(clippy::needless_borrow)]
1726 #[allow(clippy::needless_borrows_for_generic_args)]
1727 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
1728 }
1729 if self.num_ssts_sealed != 0 {
1730 struct_ser.serialize_field("numSstsSealed", &self.num_ssts_sealed)?;
1731 }
1732 if self.num_ssts_uploaded != 0 {
1733 struct_ser.serialize_field("numSstsUploaded", &self.num_ssts_uploaded)?;
1734 }
1735 if self.num_progress_key != 0 {
1736 #[allow(clippy::needless_borrow)]
1737 #[allow(clippy::needless_borrows_for_generic_args)]
1738 struct_ser.serialize_field("numProgressKey", ToString::to_string(&self.num_progress_key).as_str())?;
1739 }
1740 if self.num_pending_read_io != 0 {
1741 #[allow(clippy::needless_borrow)]
1742 #[allow(clippy::needless_borrows_for_generic_args)]
1743 struct_ser.serialize_field("numPendingReadIo", ToString::to_string(&self.num_pending_read_io).as_str())?;
1744 }
1745 if self.num_pending_write_io != 0 {
1746 #[allow(clippy::needless_borrow)]
1747 #[allow(clippy::needless_borrows_for_generic_args)]
1748 struct_ser.serialize_field("numPendingWriteIo", ToString::to_string(&self.num_pending_write_io).as_str())?;
1749 }
1750 if let Some(v) = self.compaction_group_id.as_ref() {
1751 #[allow(clippy::needless_borrow)]
1752 #[allow(clippy::needless_borrows_for_generic_args)]
1753 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&v).as_str())?;
1754 }
1755 struct_ser.end()
1756 }
1757}
1758impl<'de> serde::Deserialize<'de> for CompactTaskProgress {
1759 #[allow(deprecated)]
1760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1761 where
1762 D: serde::Deserializer<'de>,
1763 {
1764 const FIELDS: &[&str] = &[
1765 "task_id",
1766 "taskId",
1767 "num_ssts_sealed",
1768 "numSstsSealed",
1769 "num_ssts_uploaded",
1770 "numSstsUploaded",
1771 "num_progress_key",
1772 "numProgressKey",
1773 "num_pending_read_io",
1774 "numPendingReadIo",
1775 "num_pending_write_io",
1776 "numPendingWriteIo",
1777 "compaction_group_id",
1778 "compactionGroupId",
1779 ];
1780
1781 #[allow(clippy::enum_variant_names)]
1782 enum GeneratedField {
1783 TaskId,
1784 NumSstsSealed,
1785 NumSstsUploaded,
1786 NumProgressKey,
1787 NumPendingReadIo,
1788 NumPendingWriteIo,
1789 CompactionGroupId,
1790 }
1791 impl<'de> serde::Deserialize<'de> for GeneratedField {
1792 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1793 where
1794 D: serde::Deserializer<'de>,
1795 {
1796 struct GeneratedVisitor;
1797
1798 impl serde::de::Visitor<'_> for GeneratedVisitor {
1799 type Value = GeneratedField;
1800
1801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1802 write!(formatter, "expected one of: {:?}", &FIELDS)
1803 }
1804
1805 #[allow(unused_variables)]
1806 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1807 where
1808 E: serde::de::Error,
1809 {
1810 match value {
1811 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1812 "numSstsSealed" | "num_ssts_sealed" => Ok(GeneratedField::NumSstsSealed),
1813 "numSstsUploaded" | "num_ssts_uploaded" => Ok(GeneratedField::NumSstsUploaded),
1814 "numProgressKey" | "num_progress_key" => Ok(GeneratedField::NumProgressKey),
1815 "numPendingReadIo" | "num_pending_read_io" => Ok(GeneratedField::NumPendingReadIo),
1816 "numPendingWriteIo" | "num_pending_write_io" => Ok(GeneratedField::NumPendingWriteIo),
1817 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1818 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1819 }
1820 }
1821 }
1822 deserializer.deserialize_identifier(GeneratedVisitor)
1823 }
1824 }
1825 struct GeneratedVisitor;
1826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1827 type Value = CompactTaskProgress;
1828
1829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1830 formatter.write_str("struct hummock.CompactTaskProgress")
1831 }
1832
1833 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskProgress, V::Error>
1834 where
1835 V: serde::de::MapAccess<'de>,
1836 {
1837 let mut task_id__ = None;
1838 let mut num_ssts_sealed__ = None;
1839 let mut num_ssts_uploaded__ = None;
1840 let mut num_progress_key__ = None;
1841 let mut num_pending_read_io__ = None;
1842 let mut num_pending_write_io__ = None;
1843 let mut compaction_group_id__ = None;
1844 while let Some(k) = map_.next_key()? {
1845 match k {
1846 GeneratedField::TaskId => {
1847 if task_id__.is_some() {
1848 return Err(serde::de::Error::duplicate_field("taskId"));
1849 }
1850 task_id__ =
1851 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1852 ;
1853 }
1854 GeneratedField::NumSstsSealed => {
1855 if num_ssts_sealed__.is_some() {
1856 return Err(serde::de::Error::duplicate_field("numSstsSealed"));
1857 }
1858 num_ssts_sealed__ =
1859 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1860 ;
1861 }
1862 GeneratedField::NumSstsUploaded => {
1863 if num_ssts_uploaded__.is_some() {
1864 return Err(serde::de::Error::duplicate_field("numSstsUploaded"));
1865 }
1866 num_ssts_uploaded__ =
1867 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1868 ;
1869 }
1870 GeneratedField::NumProgressKey => {
1871 if num_progress_key__.is_some() {
1872 return Err(serde::de::Error::duplicate_field("numProgressKey"));
1873 }
1874 num_progress_key__ =
1875 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1876 ;
1877 }
1878 GeneratedField::NumPendingReadIo => {
1879 if num_pending_read_io__.is_some() {
1880 return Err(serde::de::Error::duplicate_field("numPendingReadIo"));
1881 }
1882 num_pending_read_io__ =
1883 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1884 ;
1885 }
1886 GeneratedField::NumPendingWriteIo => {
1887 if num_pending_write_io__.is_some() {
1888 return Err(serde::de::Error::duplicate_field("numPendingWriteIo"));
1889 }
1890 num_pending_write_io__ =
1891 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1892 ;
1893 }
1894 GeneratedField::CompactionGroupId => {
1895 if compaction_group_id__.is_some() {
1896 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1897 }
1898 compaction_group_id__ =
1899 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1900 ;
1901 }
1902 }
1903 }
1904 Ok(CompactTaskProgress {
1905 task_id: task_id__.unwrap_or_default(),
1906 num_ssts_sealed: num_ssts_sealed__.unwrap_or_default(),
1907 num_ssts_uploaded: num_ssts_uploaded__.unwrap_or_default(),
1908 num_progress_key: num_progress_key__.unwrap_or_default(),
1909 num_pending_read_io: num_pending_read_io__.unwrap_or_default(),
1910 num_pending_write_io: num_pending_write_io__.unwrap_or_default(),
1911 compaction_group_id: compaction_group_id__,
1912 })
1913 }
1914 }
1915 deserializer.deserialize_struct("hummock.CompactTaskProgress", FIELDS, GeneratedVisitor)
1916 }
1917}
1918impl serde::Serialize for CompactionConfig {
1919 #[allow(deprecated)]
1920 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1921 where
1922 S: serde::Serializer,
1923 {
1924 use serde::ser::SerializeStruct;
1925 let mut len = 0;
1926 if self.max_bytes_for_level_base != 0 {
1927 len += 1;
1928 }
1929 if self.max_level != 0 {
1930 len += 1;
1931 }
1932 if self.max_bytes_for_level_multiplier != 0 {
1933 len += 1;
1934 }
1935 if self.max_compaction_bytes != 0 {
1936 len += 1;
1937 }
1938 if self.sub_level_max_compaction_bytes != 0 {
1939 len += 1;
1940 }
1941 if self.level0_tier_compact_file_number != 0 {
1942 len += 1;
1943 }
1944 if self.compaction_mode != 0 {
1945 len += 1;
1946 }
1947 if !self.compression_algorithm.is_empty() {
1948 len += 1;
1949 }
1950 if self.target_file_size_base != 0 {
1951 len += 1;
1952 }
1953 if self.compaction_filter_mask != 0 {
1954 len += 1;
1955 }
1956 if self.max_sub_compaction != 0 {
1957 len += 1;
1958 }
1959 if self.max_space_reclaim_bytes != 0 {
1960 len += 1;
1961 }
1962 if self.split_by_state_table {
1963 len += 1;
1964 }
1965 if self.split_weight_by_vnode != 0 {
1966 len += 1;
1967 }
1968 if self.level0_stop_write_threshold_sub_level_number != 0 {
1969 len += 1;
1970 }
1971 if self.level0_max_compact_file_number != 0 {
1972 len += 1;
1973 }
1974 if self.level0_sub_level_compact_level_count != 0 {
1975 len += 1;
1976 }
1977 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1978 len += 1;
1979 }
1980 if self.tombstone_reclaim_ratio != 0 {
1981 len += 1;
1982 }
1983 if self.enable_emergency_picker {
1984 len += 1;
1985 }
1986 if self.max_l0_compact_level_count.is_some() {
1987 len += 1;
1988 }
1989 if self.sst_allowed_trivial_move_min_size.is_some() {
1990 len += 1;
1991 }
1992 if self.disable_auto_group_scheduling.is_some() {
1993 len += 1;
1994 }
1995 if self.max_overlapping_level_size.is_some() {
1996 len += 1;
1997 }
1998 if self.emergency_level0_sst_file_count.is_some() {
1999 len += 1;
2000 }
2001 if self.emergency_level0_sub_level_partition.is_some() {
2002 len += 1;
2003 }
2004 if self.level0_stop_write_threshold_max_sst_count.is_some() {
2005 len += 1;
2006 }
2007 if self.level0_stop_write_threshold_max_size.is_some() {
2008 len += 1;
2009 }
2010 if self.sst_allowed_trivial_move_max_count.is_some() {
2011 len += 1;
2012 }
2013 if self.enable_optimize_l0_interval_selection.is_some() {
2014 len += 1;
2015 }
2016 if self.vnode_aligned_level_size_threshold.is_some() {
2017 len += 1;
2018 }
2019 if self.max_kv_count_for_xor16.is_some() {
2020 len += 1;
2021 }
2022 if self.max_vnode_key_range_bytes.is_some() {
2023 len += 1;
2024 }
2025 if !self.sstable_filter_kind.is_empty() {
2026 len += 1;
2027 }
2028 if !self.sstable_filter_layout.is_empty() {
2029 len += 1;
2030 }
2031 let mut struct_ser = serializer.serialize_struct("hummock.CompactionConfig", len)?;
2032 if self.max_bytes_for_level_base != 0 {
2033 #[allow(clippy::needless_borrow)]
2034 #[allow(clippy::needless_borrows_for_generic_args)]
2035 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&self.max_bytes_for_level_base).as_str())?;
2036 }
2037 if self.max_level != 0 {
2038 #[allow(clippy::needless_borrow)]
2039 #[allow(clippy::needless_borrows_for_generic_args)]
2040 struct_ser.serialize_field("maxLevel", ToString::to_string(&self.max_level).as_str())?;
2041 }
2042 if self.max_bytes_for_level_multiplier != 0 {
2043 #[allow(clippy::needless_borrow)]
2044 #[allow(clippy::needless_borrows_for_generic_args)]
2045 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&self.max_bytes_for_level_multiplier).as_str())?;
2046 }
2047 if self.max_compaction_bytes != 0 {
2048 #[allow(clippy::needless_borrow)]
2049 #[allow(clippy::needless_borrows_for_generic_args)]
2050 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&self.max_compaction_bytes).as_str())?;
2051 }
2052 if self.sub_level_max_compaction_bytes != 0 {
2053 #[allow(clippy::needless_borrow)]
2054 #[allow(clippy::needless_borrows_for_generic_args)]
2055 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&self.sub_level_max_compaction_bytes).as_str())?;
2056 }
2057 if self.level0_tier_compact_file_number != 0 {
2058 #[allow(clippy::needless_borrow)]
2059 #[allow(clippy::needless_borrows_for_generic_args)]
2060 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&self.level0_tier_compact_file_number).as_str())?;
2061 }
2062 if self.compaction_mode != 0 {
2063 let v = compaction_config::CompactionMode::try_from(self.compaction_mode)
2064 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compaction_mode)))?;
2065 struct_ser.serialize_field("compactionMode", &v)?;
2066 }
2067 if !self.compression_algorithm.is_empty() {
2068 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
2069 }
2070 if self.target_file_size_base != 0 {
2071 #[allow(clippy::needless_borrow)]
2072 #[allow(clippy::needless_borrows_for_generic_args)]
2073 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&self.target_file_size_base).as_str())?;
2074 }
2075 if self.compaction_filter_mask != 0 {
2076 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
2077 }
2078 if self.max_sub_compaction != 0 {
2079 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
2080 }
2081 if self.max_space_reclaim_bytes != 0 {
2082 #[allow(clippy::needless_borrow)]
2083 #[allow(clippy::needless_borrows_for_generic_args)]
2084 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&self.max_space_reclaim_bytes).as_str())?;
2085 }
2086 if self.split_by_state_table {
2087 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
2088 }
2089 if self.split_weight_by_vnode != 0 {
2090 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
2091 }
2092 if self.level0_stop_write_threshold_sub_level_number != 0 {
2093 #[allow(clippy::needless_borrow)]
2094 #[allow(clippy::needless_borrows_for_generic_args)]
2095 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&self.level0_stop_write_threshold_sub_level_number).as_str())?;
2096 }
2097 if self.level0_max_compact_file_number != 0 {
2098 #[allow(clippy::needless_borrow)]
2099 #[allow(clippy::needless_borrows_for_generic_args)]
2100 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&self.level0_max_compact_file_number).as_str())?;
2101 }
2102 if self.level0_sub_level_compact_level_count != 0 {
2103 struct_ser.serialize_field("level0SubLevelCompactLevelCount", &self.level0_sub_level_compact_level_count)?;
2104 }
2105 if self.level0_overlapping_sub_level_compact_level_count != 0 {
2106 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", &self.level0_overlapping_sub_level_compact_level_count)?;
2107 }
2108 if self.tombstone_reclaim_ratio != 0 {
2109 struct_ser.serialize_field("tombstoneReclaimRatio", &self.tombstone_reclaim_ratio)?;
2110 }
2111 if self.enable_emergency_picker {
2112 struct_ser.serialize_field("enableEmergencyPicker", &self.enable_emergency_picker)?;
2113 }
2114 if let Some(v) = self.max_l0_compact_level_count.as_ref() {
2115 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
2116 }
2117 if let Some(v) = self.sst_allowed_trivial_move_min_size.as_ref() {
2118 #[allow(clippy::needless_borrow)]
2119 #[allow(clippy::needless_borrows_for_generic_args)]
2120 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
2121 }
2122 if let Some(v) = self.disable_auto_group_scheduling.as_ref() {
2123 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
2124 }
2125 if let Some(v) = self.max_overlapping_level_size.as_ref() {
2126 #[allow(clippy::needless_borrow)]
2127 #[allow(clippy::needless_borrows_for_generic_args)]
2128 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
2129 }
2130 if let Some(v) = self.emergency_level0_sst_file_count.as_ref() {
2131 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
2132 }
2133 if let Some(v) = self.emergency_level0_sub_level_partition.as_ref() {
2134 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
2135 }
2136 if let Some(v) = self.level0_stop_write_threshold_max_sst_count.as_ref() {
2137 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
2138 }
2139 if let Some(v) = self.level0_stop_write_threshold_max_size.as_ref() {
2140 #[allow(clippy::needless_borrow)]
2141 #[allow(clippy::needless_borrows_for_generic_args)]
2142 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
2143 }
2144 if let Some(v) = self.sst_allowed_trivial_move_max_count.as_ref() {
2145 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
2146 }
2147 if let Some(v) = self.enable_optimize_l0_interval_selection.as_ref() {
2148 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
2149 }
2150 if let Some(v) = self.vnode_aligned_level_size_threshold.as_ref() {
2151 #[allow(clippy::needless_borrow)]
2152 #[allow(clippy::needless_borrows_for_generic_args)]
2153 struct_ser.serialize_field("vnodeAlignedLevelSizeThreshold", ToString::to_string(&v).as_str())?;
2154 }
2155 if let Some(v) = self.max_kv_count_for_xor16.as_ref() {
2156 #[allow(clippy::needless_borrow)]
2157 #[allow(clippy::needless_borrows_for_generic_args)]
2158 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
2159 }
2160 if let Some(v) = self.max_vnode_key_range_bytes.as_ref() {
2161 #[allow(clippy::needless_borrow)]
2162 #[allow(clippy::needless_borrows_for_generic_args)]
2163 struct_ser.serialize_field("maxVnodeKeyRangeBytes", ToString::to_string(&v).as_str())?;
2164 }
2165 if !self.sstable_filter_kind.is_empty() {
2166 struct_ser.serialize_field("sstableFilterKind", &self.sstable_filter_kind)?;
2167 }
2168 if !self.sstable_filter_layout.is_empty() {
2169 struct_ser.serialize_field("sstableFilterLayout", &self.sstable_filter_layout)?;
2170 }
2171 struct_ser.end()
2172 }
2173}
2174impl<'de> serde::Deserialize<'de> for CompactionConfig {
2175 #[allow(deprecated)]
2176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2177 where
2178 D: serde::Deserializer<'de>,
2179 {
2180 const FIELDS: &[&str] = &[
2181 "max_bytes_for_level_base",
2182 "maxBytesForLevelBase",
2183 "max_level",
2184 "maxLevel",
2185 "max_bytes_for_level_multiplier",
2186 "maxBytesForLevelMultiplier",
2187 "max_compaction_bytes",
2188 "maxCompactionBytes",
2189 "sub_level_max_compaction_bytes",
2190 "subLevelMaxCompactionBytes",
2191 "level0_tier_compact_file_number",
2192 "level0TierCompactFileNumber",
2193 "compaction_mode",
2194 "compactionMode",
2195 "compression_algorithm",
2196 "compressionAlgorithm",
2197 "target_file_size_base",
2198 "targetFileSizeBase",
2199 "compaction_filter_mask",
2200 "compactionFilterMask",
2201 "max_sub_compaction",
2202 "maxSubCompaction",
2203 "max_space_reclaim_bytes",
2204 "maxSpaceReclaimBytes",
2205 "split_by_state_table",
2206 "splitByStateTable",
2207 "split_weight_by_vnode",
2208 "splitWeightByVnode",
2209 "level0_stop_write_threshold_sub_level_number",
2210 "level0StopWriteThresholdSubLevelNumber",
2211 "level0_max_compact_file_number",
2212 "level0MaxCompactFileNumber",
2213 "level0_sub_level_compact_level_count",
2214 "level0SubLevelCompactLevelCount",
2215 "level0_overlapping_sub_level_compact_level_count",
2216 "level0OverlappingSubLevelCompactLevelCount",
2217 "tombstone_reclaim_ratio",
2218 "tombstoneReclaimRatio",
2219 "enable_emergency_picker",
2220 "enableEmergencyPicker",
2221 "max_l0_compact_level_count",
2222 "maxL0CompactLevelCount",
2223 "sst_allowed_trivial_move_min_size",
2224 "sstAllowedTrivialMoveMinSize",
2225 "disable_auto_group_scheduling",
2226 "disableAutoGroupScheduling",
2227 "max_overlapping_level_size",
2228 "maxOverlappingLevelSize",
2229 "emergency_level0_sst_file_count",
2230 "emergencyLevel0SstFileCount",
2231 "emergency_level0_sub_level_partition",
2232 "emergencyLevel0SubLevelPartition",
2233 "level0_stop_write_threshold_max_sst_count",
2234 "level0StopWriteThresholdMaxSstCount",
2235 "level0_stop_write_threshold_max_size",
2236 "level0StopWriteThresholdMaxSize",
2237 "sst_allowed_trivial_move_max_count",
2238 "sstAllowedTrivialMoveMaxCount",
2239 "enable_optimize_l0_interval_selection",
2240 "enableOptimizeL0IntervalSelection",
2241 "vnode_aligned_level_size_threshold",
2242 "vnodeAlignedLevelSizeThreshold",
2243 "max_kv_count_for_xor16",
2244 "maxKvCountForXor16",
2245 "max_vnode_key_range_bytes",
2246 "maxVnodeKeyRangeBytes",
2247 "sstable_filter_kind",
2248 "sstableFilterKind",
2249 "sstable_filter_layout",
2250 "sstableFilterLayout",
2251 ];
2252
2253 #[allow(clippy::enum_variant_names)]
2254 enum GeneratedField {
2255 MaxBytesForLevelBase,
2256 MaxLevel,
2257 MaxBytesForLevelMultiplier,
2258 MaxCompactionBytes,
2259 SubLevelMaxCompactionBytes,
2260 Level0TierCompactFileNumber,
2261 CompactionMode,
2262 CompressionAlgorithm,
2263 TargetFileSizeBase,
2264 CompactionFilterMask,
2265 MaxSubCompaction,
2266 MaxSpaceReclaimBytes,
2267 SplitByStateTable,
2268 SplitWeightByVnode,
2269 Level0StopWriteThresholdSubLevelNumber,
2270 Level0MaxCompactFileNumber,
2271 Level0SubLevelCompactLevelCount,
2272 Level0OverlappingSubLevelCompactLevelCount,
2273 TombstoneReclaimRatio,
2274 EnableEmergencyPicker,
2275 MaxL0CompactLevelCount,
2276 SstAllowedTrivialMoveMinSize,
2277 DisableAutoGroupScheduling,
2278 MaxOverlappingLevelSize,
2279 EmergencyLevel0SstFileCount,
2280 EmergencyLevel0SubLevelPartition,
2281 Level0StopWriteThresholdMaxSstCount,
2282 Level0StopWriteThresholdMaxSize,
2283 SstAllowedTrivialMoveMaxCount,
2284 EnableOptimizeL0IntervalSelection,
2285 VnodeAlignedLevelSizeThreshold,
2286 MaxKvCountForXor16,
2287 MaxVnodeKeyRangeBytes,
2288 SstableFilterKind,
2289 SstableFilterLayout,
2290 }
2291 impl<'de> serde::Deserialize<'de> for GeneratedField {
2292 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2293 where
2294 D: serde::Deserializer<'de>,
2295 {
2296 struct GeneratedVisitor;
2297
2298 impl serde::de::Visitor<'_> for GeneratedVisitor {
2299 type Value = GeneratedField;
2300
2301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2302 write!(formatter, "expected one of: {:?}", &FIELDS)
2303 }
2304
2305 #[allow(unused_variables)]
2306 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2307 where
2308 E: serde::de::Error,
2309 {
2310 match value {
2311 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
2312 "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2313 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
2314 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
2315 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
2316 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
2317 "compactionMode" | "compaction_mode" => Ok(GeneratedField::CompactionMode),
2318 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
2319 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
2320 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
2321 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
2322 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
2323 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
2324 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
2325 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
2326 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
2327 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
2328 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
2329 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
2330 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
2331 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
2332 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
2333 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
2334 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
2335 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
2336 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
2337 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
2338 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
2339 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
2340 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
2341 "vnodeAlignedLevelSizeThreshold" | "vnode_aligned_level_size_threshold" => Ok(GeneratedField::VnodeAlignedLevelSizeThreshold),
2342 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
2343 "maxVnodeKeyRangeBytes" | "max_vnode_key_range_bytes" => Ok(GeneratedField::MaxVnodeKeyRangeBytes),
2344 "sstableFilterKind" | "sstable_filter_kind" => Ok(GeneratedField::SstableFilterKind),
2345 "sstableFilterLayout" | "sstable_filter_layout" => Ok(GeneratedField::SstableFilterLayout),
2346 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2347 }
2348 }
2349 }
2350 deserializer.deserialize_identifier(GeneratedVisitor)
2351 }
2352 }
2353 struct GeneratedVisitor;
2354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2355 type Value = CompactionConfig;
2356
2357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2358 formatter.write_str("struct hummock.CompactionConfig")
2359 }
2360
2361 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionConfig, V::Error>
2362 where
2363 V: serde::de::MapAccess<'de>,
2364 {
2365 let mut max_bytes_for_level_base__ = None;
2366 let mut max_level__ = None;
2367 let mut max_bytes_for_level_multiplier__ = None;
2368 let mut max_compaction_bytes__ = None;
2369 let mut sub_level_max_compaction_bytes__ = None;
2370 let mut level0_tier_compact_file_number__ = None;
2371 let mut compaction_mode__ = None;
2372 let mut compression_algorithm__ = None;
2373 let mut target_file_size_base__ = None;
2374 let mut compaction_filter_mask__ = None;
2375 let mut max_sub_compaction__ = None;
2376 let mut max_space_reclaim_bytes__ = None;
2377 let mut split_by_state_table__ = None;
2378 let mut split_weight_by_vnode__ = None;
2379 let mut level0_stop_write_threshold_sub_level_number__ = None;
2380 let mut level0_max_compact_file_number__ = None;
2381 let mut level0_sub_level_compact_level_count__ = None;
2382 let mut level0_overlapping_sub_level_compact_level_count__ = None;
2383 let mut tombstone_reclaim_ratio__ = None;
2384 let mut enable_emergency_picker__ = None;
2385 let mut max_l0_compact_level_count__ = None;
2386 let mut sst_allowed_trivial_move_min_size__ = None;
2387 let mut disable_auto_group_scheduling__ = None;
2388 let mut max_overlapping_level_size__ = None;
2389 let mut emergency_level0_sst_file_count__ = None;
2390 let mut emergency_level0_sub_level_partition__ = None;
2391 let mut level0_stop_write_threshold_max_sst_count__ = None;
2392 let mut level0_stop_write_threshold_max_size__ = None;
2393 let mut sst_allowed_trivial_move_max_count__ = None;
2394 let mut enable_optimize_l0_interval_selection__ = None;
2395 let mut vnode_aligned_level_size_threshold__ = None;
2396 let mut max_kv_count_for_xor16__ = None;
2397 let mut max_vnode_key_range_bytes__ = None;
2398 let mut sstable_filter_kind__ = None;
2399 let mut sstable_filter_layout__ = None;
2400 while let Some(k) = map_.next_key()? {
2401 match k {
2402 GeneratedField::MaxBytesForLevelBase => {
2403 if max_bytes_for_level_base__.is_some() {
2404 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
2405 }
2406 max_bytes_for_level_base__ =
2407 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2408 ;
2409 }
2410 GeneratedField::MaxLevel => {
2411 if max_level__.is_some() {
2412 return Err(serde::de::Error::duplicate_field("maxLevel"));
2413 }
2414 max_level__ =
2415 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2416 ;
2417 }
2418 GeneratedField::MaxBytesForLevelMultiplier => {
2419 if max_bytes_for_level_multiplier__.is_some() {
2420 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
2421 }
2422 max_bytes_for_level_multiplier__ =
2423 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2424 ;
2425 }
2426 GeneratedField::MaxCompactionBytes => {
2427 if max_compaction_bytes__.is_some() {
2428 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
2429 }
2430 max_compaction_bytes__ =
2431 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2432 ;
2433 }
2434 GeneratedField::SubLevelMaxCompactionBytes => {
2435 if sub_level_max_compaction_bytes__.is_some() {
2436 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
2437 }
2438 sub_level_max_compaction_bytes__ =
2439 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2440 ;
2441 }
2442 GeneratedField::Level0TierCompactFileNumber => {
2443 if level0_tier_compact_file_number__.is_some() {
2444 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
2445 }
2446 level0_tier_compact_file_number__ =
2447 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2448 ;
2449 }
2450 GeneratedField::CompactionMode => {
2451 if compaction_mode__.is_some() {
2452 return Err(serde::de::Error::duplicate_field("compactionMode"));
2453 }
2454 compaction_mode__ = Some(map_.next_value::<compaction_config::CompactionMode>()? as i32);
2455 }
2456 GeneratedField::CompressionAlgorithm => {
2457 if compression_algorithm__.is_some() {
2458 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
2459 }
2460 compression_algorithm__ = Some(map_.next_value()?);
2461 }
2462 GeneratedField::TargetFileSizeBase => {
2463 if target_file_size_base__.is_some() {
2464 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
2465 }
2466 target_file_size_base__ =
2467 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2468 ;
2469 }
2470 GeneratedField::CompactionFilterMask => {
2471 if compaction_filter_mask__.is_some() {
2472 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
2473 }
2474 compaction_filter_mask__ =
2475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2476 ;
2477 }
2478 GeneratedField::MaxSubCompaction => {
2479 if max_sub_compaction__.is_some() {
2480 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
2481 }
2482 max_sub_compaction__ =
2483 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2484 ;
2485 }
2486 GeneratedField::MaxSpaceReclaimBytes => {
2487 if max_space_reclaim_bytes__.is_some() {
2488 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
2489 }
2490 max_space_reclaim_bytes__ =
2491 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2492 ;
2493 }
2494 GeneratedField::SplitByStateTable => {
2495 if split_by_state_table__.is_some() {
2496 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
2497 }
2498 split_by_state_table__ = Some(map_.next_value()?);
2499 }
2500 GeneratedField::SplitWeightByVnode => {
2501 if split_weight_by_vnode__.is_some() {
2502 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
2503 }
2504 split_weight_by_vnode__ =
2505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2506 ;
2507 }
2508 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
2509 if level0_stop_write_threshold_sub_level_number__.is_some() {
2510 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
2511 }
2512 level0_stop_write_threshold_sub_level_number__ =
2513 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2514 ;
2515 }
2516 GeneratedField::Level0MaxCompactFileNumber => {
2517 if level0_max_compact_file_number__.is_some() {
2518 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
2519 }
2520 level0_max_compact_file_number__ =
2521 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2522 ;
2523 }
2524 GeneratedField::Level0SubLevelCompactLevelCount => {
2525 if level0_sub_level_compact_level_count__.is_some() {
2526 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
2527 }
2528 level0_sub_level_compact_level_count__ =
2529 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2530 ;
2531 }
2532 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
2533 if level0_overlapping_sub_level_compact_level_count__.is_some() {
2534 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
2535 }
2536 level0_overlapping_sub_level_compact_level_count__ =
2537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2538 ;
2539 }
2540 GeneratedField::TombstoneReclaimRatio => {
2541 if tombstone_reclaim_ratio__.is_some() {
2542 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
2543 }
2544 tombstone_reclaim_ratio__ =
2545 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2546 ;
2547 }
2548 GeneratedField::EnableEmergencyPicker => {
2549 if enable_emergency_picker__.is_some() {
2550 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
2551 }
2552 enable_emergency_picker__ = Some(map_.next_value()?);
2553 }
2554 GeneratedField::MaxL0CompactLevelCount => {
2555 if max_l0_compact_level_count__.is_some() {
2556 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
2557 }
2558 max_l0_compact_level_count__ =
2559 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2560 ;
2561 }
2562 GeneratedField::SstAllowedTrivialMoveMinSize => {
2563 if sst_allowed_trivial_move_min_size__.is_some() {
2564 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
2565 }
2566 sst_allowed_trivial_move_min_size__ =
2567 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2568 ;
2569 }
2570 GeneratedField::DisableAutoGroupScheduling => {
2571 if disable_auto_group_scheduling__.is_some() {
2572 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
2573 }
2574 disable_auto_group_scheduling__ = map_.next_value()?;
2575 }
2576 GeneratedField::MaxOverlappingLevelSize => {
2577 if max_overlapping_level_size__.is_some() {
2578 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
2579 }
2580 max_overlapping_level_size__ =
2581 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2582 ;
2583 }
2584 GeneratedField::EmergencyLevel0SstFileCount => {
2585 if emergency_level0_sst_file_count__.is_some() {
2586 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
2587 }
2588 emergency_level0_sst_file_count__ =
2589 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2590 ;
2591 }
2592 GeneratedField::EmergencyLevel0SubLevelPartition => {
2593 if emergency_level0_sub_level_partition__.is_some() {
2594 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
2595 }
2596 emergency_level0_sub_level_partition__ =
2597 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2598 ;
2599 }
2600 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
2601 if level0_stop_write_threshold_max_sst_count__.is_some() {
2602 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
2603 }
2604 level0_stop_write_threshold_max_sst_count__ =
2605 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2606 ;
2607 }
2608 GeneratedField::Level0StopWriteThresholdMaxSize => {
2609 if level0_stop_write_threshold_max_size__.is_some() {
2610 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
2611 }
2612 level0_stop_write_threshold_max_size__ =
2613 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2614 ;
2615 }
2616 GeneratedField::SstAllowedTrivialMoveMaxCount => {
2617 if sst_allowed_trivial_move_max_count__.is_some() {
2618 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
2619 }
2620 sst_allowed_trivial_move_max_count__ =
2621 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2622 ;
2623 }
2624 GeneratedField::EnableOptimizeL0IntervalSelection => {
2625 if enable_optimize_l0_interval_selection__.is_some() {
2626 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
2627 }
2628 enable_optimize_l0_interval_selection__ = map_.next_value()?;
2629 }
2630 GeneratedField::VnodeAlignedLevelSizeThreshold => {
2631 if vnode_aligned_level_size_threshold__.is_some() {
2632 return Err(serde::de::Error::duplicate_field("vnodeAlignedLevelSizeThreshold"));
2633 }
2634 vnode_aligned_level_size_threshold__ =
2635 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2636 ;
2637 }
2638 GeneratedField::MaxKvCountForXor16 => {
2639 if max_kv_count_for_xor16__.is_some() {
2640 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
2641 }
2642 max_kv_count_for_xor16__ =
2643 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2644 ;
2645 }
2646 GeneratedField::MaxVnodeKeyRangeBytes => {
2647 if max_vnode_key_range_bytes__.is_some() {
2648 return Err(serde::de::Error::duplicate_field("maxVnodeKeyRangeBytes"));
2649 }
2650 max_vnode_key_range_bytes__ =
2651 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2652 ;
2653 }
2654 GeneratedField::SstableFilterKind => {
2655 if sstable_filter_kind__.is_some() {
2656 return Err(serde::de::Error::duplicate_field("sstableFilterKind"));
2657 }
2658 sstable_filter_kind__ = Some(map_.next_value()?);
2659 }
2660 GeneratedField::SstableFilterLayout => {
2661 if sstable_filter_layout__.is_some() {
2662 return Err(serde::de::Error::duplicate_field("sstableFilterLayout"));
2663 }
2664 sstable_filter_layout__ = Some(map_.next_value()?);
2665 }
2666 }
2667 }
2668 Ok(CompactionConfig {
2669 max_bytes_for_level_base: max_bytes_for_level_base__.unwrap_or_default(),
2670 max_level: max_level__.unwrap_or_default(),
2671 max_bytes_for_level_multiplier: max_bytes_for_level_multiplier__.unwrap_or_default(),
2672 max_compaction_bytes: max_compaction_bytes__.unwrap_or_default(),
2673 sub_level_max_compaction_bytes: sub_level_max_compaction_bytes__.unwrap_or_default(),
2674 level0_tier_compact_file_number: level0_tier_compact_file_number__.unwrap_or_default(),
2675 compaction_mode: compaction_mode__.unwrap_or_default(),
2676 compression_algorithm: compression_algorithm__.unwrap_or_default(),
2677 target_file_size_base: target_file_size_base__.unwrap_or_default(),
2678 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
2679 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
2680 max_space_reclaim_bytes: max_space_reclaim_bytes__.unwrap_or_default(),
2681 split_by_state_table: split_by_state_table__.unwrap_or_default(),
2682 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
2683 level0_stop_write_threshold_sub_level_number: level0_stop_write_threshold_sub_level_number__.unwrap_or_default(),
2684 level0_max_compact_file_number: level0_max_compact_file_number__.unwrap_or_default(),
2685 level0_sub_level_compact_level_count: level0_sub_level_compact_level_count__.unwrap_or_default(),
2686 level0_overlapping_sub_level_compact_level_count: level0_overlapping_sub_level_compact_level_count__.unwrap_or_default(),
2687 tombstone_reclaim_ratio: tombstone_reclaim_ratio__.unwrap_or_default(),
2688 enable_emergency_picker: enable_emergency_picker__.unwrap_or_default(),
2689 max_l0_compact_level_count: max_l0_compact_level_count__,
2690 sst_allowed_trivial_move_min_size: sst_allowed_trivial_move_min_size__,
2691 disable_auto_group_scheduling: disable_auto_group_scheduling__,
2692 max_overlapping_level_size: max_overlapping_level_size__,
2693 emergency_level0_sst_file_count: emergency_level0_sst_file_count__,
2694 emergency_level0_sub_level_partition: emergency_level0_sub_level_partition__,
2695 level0_stop_write_threshold_max_sst_count: level0_stop_write_threshold_max_sst_count__,
2696 level0_stop_write_threshold_max_size: level0_stop_write_threshold_max_size__,
2697 sst_allowed_trivial_move_max_count: sst_allowed_trivial_move_max_count__,
2698 enable_optimize_l0_interval_selection: enable_optimize_l0_interval_selection__,
2699 vnode_aligned_level_size_threshold: vnode_aligned_level_size_threshold__,
2700 max_kv_count_for_xor16: max_kv_count_for_xor16__,
2701 max_vnode_key_range_bytes: max_vnode_key_range_bytes__,
2702 sstable_filter_kind: sstable_filter_kind__.unwrap_or_default(),
2703 sstable_filter_layout: sstable_filter_layout__.unwrap_or_default(),
2704 })
2705 }
2706 }
2707 deserializer.deserialize_struct("hummock.CompactionConfig", FIELDS, GeneratedVisitor)
2708 }
2709}
2710impl serde::Serialize for compaction_config::CompactionMode {
2711 #[allow(deprecated)]
2712 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2713 where
2714 S: serde::Serializer,
2715 {
2716 let variant = match self {
2717 Self::Unspecified => "UNSPECIFIED",
2718 Self::Range => "RANGE",
2719 };
2720 serializer.serialize_str(variant)
2721 }
2722}
2723impl<'de> serde::Deserialize<'de> for compaction_config::CompactionMode {
2724 #[allow(deprecated)]
2725 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2726 where
2727 D: serde::Deserializer<'de>,
2728 {
2729 const FIELDS: &[&str] = &[
2730 "UNSPECIFIED",
2731 "RANGE",
2732 ];
2733
2734 struct GeneratedVisitor;
2735
2736 impl serde::de::Visitor<'_> for GeneratedVisitor {
2737 type Value = compaction_config::CompactionMode;
2738
2739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2740 write!(formatter, "expected one of: {:?}", &FIELDS)
2741 }
2742
2743 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2744 where
2745 E: serde::de::Error,
2746 {
2747 i32::try_from(v)
2748 .ok()
2749 .and_then(|x| x.try_into().ok())
2750 .ok_or_else(|| {
2751 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2752 })
2753 }
2754
2755 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2756 where
2757 E: serde::de::Error,
2758 {
2759 i32::try_from(v)
2760 .ok()
2761 .and_then(|x| x.try_into().ok())
2762 .ok_or_else(|| {
2763 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2764 })
2765 }
2766
2767 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2768 where
2769 E: serde::de::Error,
2770 {
2771 match value {
2772 "UNSPECIFIED" => Ok(compaction_config::CompactionMode::Unspecified),
2773 "RANGE" => Ok(compaction_config::CompactionMode::Range),
2774 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2775 }
2776 }
2777 }
2778 deserializer.deserialize_any(GeneratedVisitor)
2779 }
2780}
2781impl serde::Serialize for CompactionGroup {
2782 #[allow(deprecated)]
2783 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2784 where
2785 S: serde::Serializer,
2786 {
2787 use serde::ser::SerializeStruct;
2788 let mut len = 0;
2789 if self.id != 0 {
2790 len += 1;
2791 }
2792 if self.compaction_config.is_some() {
2793 len += 1;
2794 }
2795 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroup", len)?;
2796 if self.id != 0 {
2797 #[allow(clippy::needless_borrow)]
2798 #[allow(clippy::needless_borrows_for_generic_args)]
2799 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2800 }
2801 if let Some(v) = self.compaction_config.as_ref() {
2802 struct_ser.serialize_field("compactionConfig", v)?;
2803 }
2804 struct_ser.end()
2805 }
2806}
2807impl<'de> serde::Deserialize<'de> for CompactionGroup {
2808 #[allow(deprecated)]
2809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2810 where
2811 D: serde::Deserializer<'de>,
2812 {
2813 const FIELDS: &[&str] = &[
2814 "id",
2815 "compaction_config",
2816 "compactionConfig",
2817 ];
2818
2819 #[allow(clippy::enum_variant_names)]
2820 enum GeneratedField {
2821 Id,
2822 CompactionConfig,
2823 }
2824 impl<'de> serde::Deserialize<'de> for GeneratedField {
2825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2826 where
2827 D: serde::Deserializer<'de>,
2828 {
2829 struct GeneratedVisitor;
2830
2831 impl serde::de::Visitor<'_> for GeneratedVisitor {
2832 type Value = GeneratedField;
2833
2834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2835 write!(formatter, "expected one of: {:?}", &FIELDS)
2836 }
2837
2838 #[allow(unused_variables)]
2839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2840 where
2841 E: serde::de::Error,
2842 {
2843 match value {
2844 "id" => Ok(GeneratedField::Id),
2845 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2846 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2847 }
2848 }
2849 }
2850 deserializer.deserialize_identifier(GeneratedVisitor)
2851 }
2852 }
2853 struct GeneratedVisitor;
2854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2855 type Value = CompactionGroup;
2856
2857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2858 formatter.write_str("struct hummock.CompactionGroup")
2859 }
2860
2861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroup, V::Error>
2862 where
2863 V: serde::de::MapAccess<'de>,
2864 {
2865 let mut id__ = None;
2866 let mut compaction_config__ = None;
2867 while let Some(k) = map_.next_key()? {
2868 match k {
2869 GeneratedField::Id => {
2870 if id__.is_some() {
2871 return Err(serde::de::Error::duplicate_field("id"));
2872 }
2873 id__ =
2874 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2875 ;
2876 }
2877 GeneratedField::CompactionConfig => {
2878 if compaction_config__.is_some() {
2879 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2880 }
2881 compaction_config__ = map_.next_value()?;
2882 }
2883 }
2884 }
2885 Ok(CompactionGroup {
2886 id: id__.unwrap_or_default(),
2887 compaction_config: compaction_config__,
2888 })
2889 }
2890 }
2891 deserializer.deserialize_struct("hummock.CompactionGroup", FIELDS, GeneratedVisitor)
2892 }
2893}
2894impl serde::Serialize for CompactionGroupInfo {
2895 #[allow(deprecated)]
2896 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2897 where
2898 S: serde::Serializer,
2899 {
2900 use serde::ser::SerializeStruct;
2901 let mut len = 0;
2902 if self.id != 0 {
2903 len += 1;
2904 }
2905 if self.parent_id != 0 {
2906 len += 1;
2907 }
2908 if !self.member_table_ids.is_empty() {
2909 len += 1;
2910 }
2911 if self.compaction_config.is_some() {
2912 len += 1;
2913 }
2914 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroupInfo", len)?;
2915 if self.id != 0 {
2916 #[allow(clippy::needless_borrow)]
2917 #[allow(clippy::needless_borrows_for_generic_args)]
2918 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2919 }
2920 if self.parent_id != 0 {
2921 #[allow(clippy::needless_borrow)]
2922 #[allow(clippy::needless_borrows_for_generic_args)]
2923 struct_ser.serialize_field("parentId", ToString::to_string(&self.parent_id).as_str())?;
2924 }
2925 if !self.member_table_ids.is_empty() {
2926 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
2927 }
2928 if let Some(v) = self.compaction_config.as_ref() {
2929 struct_ser.serialize_field("compactionConfig", v)?;
2930 }
2931 struct_ser.end()
2932 }
2933}
2934impl<'de> serde::Deserialize<'de> for CompactionGroupInfo {
2935 #[allow(deprecated)]
2936 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2937 where
2938 D: serde::Deserializer<'de>,
2939 {
2940 const FIELDS: &[&str] = &[
2941 "id",
2942 "parent_id",
2943 "parentId",
2944 "member_table_ids",
2945 "memberTableIds",
2946 "compaction_config",
2947 "compactionConfig",
2948 ];
2949
2950 #[allow(clippy::enum_variant_names)]
2951 enum GeneratedField {
2952 Id,
2953 ParentId,
2954 MemberTableIds,
2955 CompactionConfig,
2956 }
2957 impl<'de> serde::Deserialize<'de> for GeneratedField {
2958 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2959 where
2960 D: serde::Deserializer<'de>,
2961 {
2962 struct GeneratedVisitor;
2963
2964 impl serde::de::Visitor<'_> for GeneratedVisitor {
2965 type Value = GeneratedField;
2966
2967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2968 write!(formatter, "expected one of: {:?}", &FIELDS)
2969 }
2970
2971 #[allow(unused_variables)]
2972 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2973 where
2974 E: serde::de::Error,
2975 {
2976 match value {
2977 "id" => Ok(GeneratedField::Id),
2978 "parentId" | "parent_id" => Ok(GeneratedField::ParentId),
2979 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
2980 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2981 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2982 }
2983 }
2984 }
2985 deserializer.deserialize_identifier(GeneratedVisitor)
2986 }
2987 }
2988 struct GeneratedVisitor;
2989 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2990 type Value = CompactionGroupInfo;
2991
2992 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2993 formatter.write_str("struct hummock.CompactionGroupInfo")
2994 }
2995
2996 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroupInfo, V::Error>
2997 where
2998 V: serde::de::MapAccess<'de>,
2999 {
3000 let mut id__ = None;
3001 let mut parent_id__ = None;
3002 let mut member_table_ids__ = None;
3003 let mut compaction_config__ = None;
3004 while let Some(k) = map_.next_key()? {
3005 match k {
3006 GeneratedField::Id => {
3007 if id__.is_some() {
3008 return Err(serde::de::Error::duplicate_field("id"));
3009 }
3010 id__ =
3011 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3012 ;
3013 }
3014 GeneratedField::ParentId => {
3015 if parent_id__.is_some() {
3016 return Err(serde::de::Error::duplicate_field("parentId"));
3017 }
3018 parent_id__ =
3019 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3020 ;
3021 }
3022 GeneratedField::MemberTableIds => {
3023 if member_table_ids__.is_some() {
3024 return Err(serde::de::Error::duplicate_field("memberTableIds"));
3025 }
3026 member_table_ids__ =
3027 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3028 .into_iter().map(|x| x.0).collect())
3029 ;
3030 }
3031 GeneratedField::CompactionConfig => {
3032 if compaction_config__.is_some() {
3033 return Err(serde::de::Error::duplicate_field("compactionConfig"));
3034 }
3035 compaction_config__ = map_.next_value()?;
3036 }
3037 }
3038 }
3039 Ok(CompactionGroupInfo {
3040 id: id__.unwrap_or_default(),
3041 parent_id: parent_id__.unwrap_or_default(),
3042 member_table_ids: member_table_ids__.unwrap_or_default(),
3043 compaction_config: compaction_config__,
3044 })
3045 }
3046 }
3047 deserializer.deserialize_struct("hummock.CompactionGroupInfo", FIELDS, GeneratedVisitor)
3048 }
3049}
3050impl serde::Serialize for CompatibilityVersion {
3051 #[allow(deprecated)]
3052 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3053 where
3054 S: serde::Serializer,
3055 {
3056 let variant = match self {
3057 Self::VersionUnspecified => "VERSION_UNSPECIFIED",
3058 Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
3059 Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
3060 Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
3061 };
3062 serializer.serialize_str(variant)
3063 }
3064}
3065impl<'de> serde::Deserialize<'de> for CompatibilityVersion {
3066 #[allow(deprecated)]
3067 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3068 where
3069 D: serde::Deserializer<'de>,
3070 {
3071 const FIELDS: &[&str] = &[
3072 "VERSION_UNSPECIFIED",
3073 "NO_TRIVIAL_SPLIT",
3074 "NO_MEMBER_TABLE_IDS",
3075 "SPLIT_GROUP_BY_TABLE_ID",
3076 ];
3077
3078 struct GeneratedVisitor;
3079
3080 impl serde::de::Visitor<'_> for GeneratedVisitor {
3081 type Value = CompatibilityVersion;
3082
3083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3084 write!(formatter, "expected one of: {:?}", &FIELDS)
3085 }
3086
3087 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3088 where
3089 E: serde::de::Error,
3090 {
3091 i32::try_from(v)
3092 .ok()
3093 .and_then(|x| x.try_into().ok())
3094 .ok_or_else(|| {
3095 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3096 })
3097 }
3098
3099 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3100 where
3101 E: serde::de::Error,
3102 {
3103 i32::try_from(v)
3104 .ok()
3105 .and_then(|x| x.try_into().ok())
3106 .ok_or_else(|| {
3107 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3108 })
3109 }
3110
3111 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3112 where
3113 E: serde::de::Error,
3114 {
3115 match value {
3116 "VERSION_UNSPECIFIED" => Ok(CompatibilityVersion::VersionUnspecified),
3117 "NO_TRIVIAL_SPLIT" => Ok(CompatibilityVersion::NoTrivialSplit),
3118 "NO_MEMBER_TABLE_IDS" => Ok(CompatibilityVersion::NoMemberTableIds),
3119 "SPLIT_GROUP_BY_TABLE_ID" => Ok(CompatibilityVersion::SplitGroupByTableId),
3120 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3121 }
3122 }
3123 }
3124 deserializer.deserialize_any(GeneratedVisitor)
3125 }
3126}
3127impl serde::Serialize for DisableCommitEpochRequest {
3128 #[allow(deprecated)]
3129 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3130 where
3131 S: serde::Serializer,
3132 {
3133 use serde::ser::SerializeStruct;
3134 let len = 0;
3135 let struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochRequest", len)?;
3136 struct_ser.end()
3137 }
3138}
3139impl<'de> serde::Deserialize<'de> for DisableCommitEpochRequest {
3140 #[allow(deprecated)]
3141 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3142 where
3143 D: serde::Deserializer<'de>,
3144 {
3145 const FIELDS: &[&str] = &[
3146 ];
3147
3148 #[allow(clippy::enum_variant_names)]
3149 enum GeneratedField {
3150 }
3151 impl<'de> serde::Deserialize<'de> for GeneratedField {
3152 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3153 where
3154 D: serde::Deserializer<'de>,
3155 {
3156 struct GeneratedVisitor;
3157
3158 impl serde::de::Visitor<'_> for GeneratedVisitor {
3159 type Value = GeneratedField;
3160
3161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3162 write!(formatter, "expected one of: {:?}", &FIELDS)
3163 }
3164
3165 #[allow(unused_variables)]
3166 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3167 where
3168 E: serde::de::Error,
3169 {
3170 Err(serde::de::Error::unknown_field(value, FIELDS))
3171 }
3172 }
3173 deserializer.deserialize_identifier(GeneratedVisitor)
3174 }
3175 }
3176 struct GeneratedVisitor;
3177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3178 type Value = DisableCommitEpochRequest;
3179
3180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3181 formatter.write_str("struct hummock.DisableCommitEpochRequest")
3182 }
3183
3184 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochRequest, V::Error>
3185 where
3186 V: serde::de::MapAccess<'de>,
3187 {
3188 while map_.next_key::<GeneratedField>()?.is_some() {
3189 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3190 }
3191 Ok(DisableCommitEpochRequest {
3192 })
3193 }
3194 }
3195 deserializer.deserialize_struct("hummock.DisableCommitEpochRequest", FIELDS, GeneratedVisitor)
3196 }
3197}
3198impl serde::Serialize for DisableCommitEpochResponse {
3199 #[allow(deprecated)]
3200 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3201 where
3202 S: serde::Serializer,
3203 {
3204 use serde::ser::SerializeStruct;
3205 let mut len = 0;
3206 if self.current_version.is_some() {
3207 len += 1;
3208 }
3209 let mut struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochResponse", len)?;
3210 if let Some(v) = self.current_version.as_ref() {
3211 struct_ser.serialize_field("currentVersion", v)?;
3212 }
3213 struct_ser.end()
3214 }
3215}
3216impl<'de> serde::Deserialize<'de> for DisableCommitEpochResponse {
3217 #[allow(deprecated)]
3218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3219 where
3220 D: serde::Deserializer<'de>,
3221 {
3222 const FIELDS: &[&str] = &[
3223 "current_version",
3224 "currentVersion",
3225 ];
3226
3227 #[allow(clippy::enum_variant_names)]
3228 enum GeneratedField {
3229 CurrentVersion,
3230 }
3231 impl<'de> serde::Deserialize<'de> for GeneratedField {
3232 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3233 where
3234 D: serde::Deserializer<'de>,
3235 {
3236 struct GeneratedVisitor;
3237
3238 impl serde::de::Visitor<'_> for GeneratedVisitor {
3239 type Value = GeneratedField;
3240
3241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3242 write!(formatter, "expected one of: {:?}", &FIELDS)
3243 }
3244
3245 #[allow(unused_variables)]
3246 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3247 where
3248 E: serde::de::Error,
3249 {
3250 match value {
3251 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
3252 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3253 }
3254 }
3255 }
3256 deserializer.deserialize_identifier(GeneratedVisitor)
3257 }
3258 }
3259 struct GeneratedVisitor;
3260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3261 type Value = DisableCommitEpochResponse;
3262
3263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3264 formatter.write_str("struct hummock.DisableCommitEpochResponse")
3265 }
3266
3267 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochResponse, V::Error>
3268 where
3269 V: serde::de::MapAccess<'de>,
3270 {
3271 let mut current_version__ = None;
3272 while let Some(k) = map_.next_key()? {
3273 match k {
3274 GeneratedField::CurrentVersion => {
3275 if current_version__.is_some() {
3276 return Err(serde::de::Error::duplicate_field("currentVersion"));
3277 }
3278 current_version__ = map_.next_value()?;
3279 }
3280 }
3281 }
3282 Ok(DisableCommitEpochResponse {
3283 current_version: current_version__,
3284 })
3285 }
3286 }
3287 deserializer.deserialize_struct("hummock.DisableCommitEpochResponse", FIELDS, GeneratedVisitor)
3288 }
3289}
3290impl serde::Serialize for EpochNewChangeLog {
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.old_value.is_empty() {
3299 len += 1;
3300 }
3301 if !self.new_value.is_empty() {
3302 len += 1;
3303 }
3304 if !self.epochs.is_empty() {
3305 len += 1;
3306 }
3307 let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3308 if !self.old_value.is_empty() {
3309 struct_ser.serialize_field("oldValue", &self.old_value)?;
3310 }
3311 if !self.new_value.is_empty() {
3312 struct_ser.serialize_field("newValue", &self.new_value)?;
3313 }
3314 if !self.epochs.is_empty() {
3315 struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3316 }
3317 struct_ser.end()
3318 }
3319}
3320impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3321 #[allow(deprecated)]
3322 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3323 where
3324 D: serde::Deserializer<'de>,
3325 {
3326 const FIELDS: &[&str] = &[
3327 "old_value",
3328 "oldValue",
3329 "new_value",
3330 "newValue",
3331 "epochs",
3332 ];
3333
3334 #[allow(clippy::enum_variant_names)]
3335 enum GeneratedField {
3336 OldValue,
3337 NewValue,
3338 Epochs,
3339 }
3340 impl<'de> serde::Deserialize<'de> for GeneratedField {
3341 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3342 where
3343 D: serde::Deserializer<'de>,
3344 {
3345 struct GeneratedVisitor;
3346
3347 impl serde::de::Visitor<'_> for GeneratedVisitor {
3348 type Value = GeneratedField;
3349
3350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3351 write!(formatter, "expected one of: {:?}", &FIELDS)
3352 }
3353
3354 #[allow(unused_variables)]
3355 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3356 where
3357 E: serde::de::Error,
3358 {
3359 match value {
3360 "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3361 "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3362 "epochs" => Ok(GeneratedField::Epochs),
3363 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3364 }
3365 }
3366 }
3367 deserializer.deserialize_identifier(GeneratedVisitor)
3368 }
3369 }
3370 struct GeneratedVisitor;
3371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3372 type Value = EpochNewChangeLog;
3373
3374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3375 formatter.write_str("struct hummock.EpochNewChangeLog")
3376 }
3377
3378 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3379 where
3380 V: serde::de::MapAccess<'de>,
3381 {
3382 let mut old_value__ = None;
3383 let mut new_value__ = None;
3384 let mut epochs__ = None;
3385 while let Some(k) = map_.next_key()? {
3386 match k {
3387 GeneratedField::OldValue => {
3388 if old_value__.is_some() {
3389 return Err(serde::de::Error::duplicate_field("oldValue"));
3390 }
3391 old_value__ = Some(map_.next_value()?);
3392 }
3393 GeneratedField::NewValue => {
3394 if new_value__.is_some() {
3395 return Err(serde::de::Error::duplicate_field("newValue"));
3396 }
3397 new_value__ = Some(map_.next_value()?);
3398 }
3399 GeneratedField::Epochs => {
3400 if epochs__.is_some() {
3401 return Err(serde::de::Error::duplicate_field("epochs"));
3402 }
3403 epochs__ =
3404 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3405 .into_iter().map(|x| x.0).collect())
3406 ;
3407 }
3408 }
3409 }
3410 Ok(EpochNewChangeLog {
3411 old_value: old_value__.unwrap_or_default(),
3412 new_value: new_value__.unwrap_or_default(),
3413 epochs: epochs__.unwrap_or_default(),
3414 })
3415 }
3416 }
3417 deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3418 }
3419}
3420impl serde::Serialize for FlatIndex {
3421 #[allow(deprecated)]
3422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3423 where
3424 S: serde::Serializer,
3425 {
3426 use serde::ser::SerializeStruct;
3427 let mut len = 0;
3428 if self.config.is_some() {
3429 len += 1;
3430 }
3431 if !self.vector_files.is_empty() {
3432 len += 1;
3433 }
3434 if self.next_vector_id != 0 {
3435 len += 1;
3436 }
3437 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3438 if let Some(v) = self.config.as_ref() {
3439 struct_ser.serialize_field("config", v)?;
3440 }
3441 if !self.vector_files.is_empty() {
3442 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3443 }
3444 if self.next_vector_id != 0 {
3445 #[allow(clippy::needless_borrow)]
3446 #[allow(clippy::needless_borrows_for_generic_args)]
3447 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3448 }
3449 struct_ser.end()
3450 }
3451}
3452impl<'de> serde::Deserialize<'de> for FlatIndex {
3453 #[allow(deprecated)]
3454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3455 where
3456 D: serde::Deserializer<'de>,
3457 {
3458 const FIELDS: &[&str] = &[
3459 "config",
3460 "vector_files",
3461 "vectorFiles",
3462 "next_vector_id",
3463 "nextVectorId",
3464 ];
3465
3466 #[allow(clippy::enum_variant_names)]
3467 enum GeneratedField {
3468 Config,
3469 VectorFiles,
3470 NextVectorId,
3471 }
3472 impl<'de> serde::Deserialize<'de> for GeneratedField {
3473 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3474 where
3475 D: serde::Deserializer<'de>,
3476 {
3477 struct GeneratedVisitor;
3478
3479 impl serde::de::Visitor<'_> for GeneratedVisitor {
3480 type Value = GeneratedField;
3481
3482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3483 write!(formatter, "expected one of: {:?}", &FIELDS)
3484 }
3485
3486 #[allow(unused_variables)]
3487 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3488 where
3489 E: serde::de::Error,
3490 {
3491 match value {
3492 "config" => Ok(GeneratedField::Config),
3493 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3494 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3495 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3496 }
3497 }
3498 }
3499 deserializer.deserialize_identifier(GeneratedVisitor)
3500 }
3501 }
3502 struct GeneratedVisitor;
3503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3504 type Value = FlatIndex;
3505
3506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3507 formatter.write_str("struct hummock.FlatIndex")
3508 }
3509
3510 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3511 where
3512 V: serde::de::MapAccess<'de>,
3513 {
3514 let mut config__ = None;
3515 let mut vector_files__ = None;
3516 let mut next_vector_id__ = None;
3517 while let Some(k) = map_.next_key()? {
3518 match k {
3519 GeneratedField::Config => {
3520 if config__.is_some() {
3521 return Err(serde::de::Error::duplicate_field("config"));
3522 }
3523 config__ = map_.next_value()?;
3524 }
3525 GeneratedField::VectorFiles => {
3526 if vector_files__.is_some() {
3527 return Err(serde::de::Error::duplicate_field("vectorFiles"));
3528 }
3529 vector_files__ = Some(map_.next_value()?);
3530 }
3531 GeneratedField::NextVectorId => {
3532 if next_vector_id__.is_some() {
3533 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3534 }
3535 next_vector_id__ =
3536 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3537 ;
3538 }
3539 }
3540 }
3541 Ok(FlatIndex {
3542 config: config__,
3543 vector_files: vector_files__.unwrap_or_default(),
3544 next_vector_id: next_vector_id__.unwrap_or_default(),
3545 })
3546 }
3547 }
3548 deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3549 }
3550}
3551impl serde::Serialize for FlatIndexAdd {
3552 #[allow(deprecated)]
3553 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3554 where
3555 S: serde::Serializer,
3556 {
3557 use serde::ser::SerializeStruct;
3558 let mut len = 0;
3559 if !self.added_vector_files.is_empty() {
3560 len += 1;
3561 }
3562 if self.next_vector_id != 0 {
3563 len += 1;
3564 }
3565 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3566 if !self.added_vector_files.is_empty() {
3567 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3568 }
3569 if self.next_vector_id != 0 {
3570 #[allow(clippy::needless_borrow)]
3571 #[allow(clippy::needless_borrows_for_generic_args)]
3572 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3573 }
3574 struct_ser.end()
3575 }
3576}
3577impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3578 #[allow(deprecated)]
3579 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3580 where
3581 D: serde::Deserializer<'de>,
3582 {
3583 const FIELDS: &[&str] = &[
3584 "added_vector_files",
3585 "addedVectorFiles",
3586 "next_vector_id",
3587 "nextVectorId",
3588 ];
3589
3590 #[allow(clippy::enum_variant_names)]
3591 enum GeneratedField {
3592 AddedVectorFiles,
3593 NextVectorId,
3594 }
3595 impl<'de> serde::Deserialize<'de> for GeneratedField {
3596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3597 where
3598 D: serde::Deserializer<'de>,
3599 {
3600 struct GeneratedVisitor;
3601
3602 impl serde::de::Visitor<'_> for GeneratedVisitor {
3603 type Value = GeneratedField;
3604
3605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3606 write!(formatter, "expected one of: {:?}", &FIELDS)
3607 }
3608
3609 #[allow(unused_variables)]
3610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3611 where
3612 E: serde::de::Error,
3613 {
3614 match value {
3615 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3616 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3618 }
3619 }
3620 }
3621 deserializer.deserialize_identifier(GeneratedVisitor)
3622 }
3623 }
3624 struct GeneratedVisitor;
3625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3626 type Value = FlatIndexAdd;
3627
3628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3629 formatter.write_str("struct hummock.FlatIndexAdd")
3630 }
3631
3632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3633 where
3634 V: serde::de::MapAccess<'de>,
3635 {
3636 let mut added_vector_files__ = None;
3637 let mut next_vector_id__ = None;
3638 while let Some(k) = map_.next_key()? {
3639 match k {
3640 GeneratedField::AddedVectorFiles => {
3641 if added_vector_files__.is_some() {
3642 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3643 }
3644 added_vector_files__ = Some(map_.next_value()?);
3645 }
3646 GeneratedField::NextVectorId => {
3647 if next_vector_id__.is_some() {
3648 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3649 }
3650 next_vector_id__ =
3651 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3652 ;
3653 }
3654 }
3655 }
3656 Ok(FlatIndexAdd {
3657 added_vector_files: added_vector_files__.unwrap_or_default(),
3658 next_vector_id: next_vector_id__.unwrap_or_default(),
3659 })
3660 }
3661 }
3662 deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3663 }
3664}
3665impl serde::Serialize for FullScanTask {
3666 #[allow(deprecated)]
3667 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3668 where
3669 S: serde::Serializer,
3670 {
3671 use serde::ser::SerializeStruct;
3672 let mut len = 0;
3673 if self.sst_retention_watermark != 0 {
3674 len += 1;
3675 }
3676 if self.prefix.is_some() {
3677 len += 1;
3678 }
3679 if self.start_after.is_some() {
3680 len += 1;
3681 }
3682 if self.limit.is_some() {
3683 len += 1;
3684 }
3685 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3686 if self.sst_retention_watermark != 0 {
3687 #[allow(clippy::needless_borrow)]
3688 #[allow(clippy::needless_borrows_for_generic_args)]
3689 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3690 }
3691 if let Some(v) = self.prefix.as_ref() {
3692 struct_ser.serialize_field("prefix", v)?;
3693 }
3694 if let Some(v) = self.start_after.as_ref() {
3695 struct_ser.serialize_field("startAfter", v)?;
3696 }
3697 if let Some(v) = self.limit.as_ref() {
3698 #[allow(clippy::needless_borrow)]
3699 #[allow(clippy::needless_borrows_for_generic_args)]
3700 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3701 }
3702 struct_ser.end()
3703 }
3704}
3705impl<'de> serde::Deserialize<'de> for FullScanTask {
3706 #[allow(deprecated)]
3707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3708 where
3709 D: serde::Deserializer<'de>,
3710 {
3711 const FIELDS: &[&str] = &[
3712 "sst_retention_watermark",
3713 "sstRetentionWatermark",
3714 "prefix",
3715 "start_after",
3716 "startAfter",
3717 "limit",
3718 ];
3719
3720 #[allow(clippy::enum_variant_names)]
3721 enum GeneratedField {
3722 SstRetentionWatermark,
3723 Prefix,
3724 StartAfter,
3725 Limit,
3726 }
3727 impl<'de> serde::Deserialize<'de> for GeneratedField {
3728 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3729 where
3730 D: serde::Deserializer<'de>,
3731 {
3732 struct GeneratedVisitor;
3733
3734 impl serde::de::Visitor<'_> for GeneratedVisitor {
3735 type Value = GeneratedField;
3736
3737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3738 write!(formatter, "expected one of: {:?}", &FIELDS)
3739 }
3740
3741 #[allow(unused_variables)]
3742 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3743 where
3744 E: serde::de::Error,
3745 {
3746 match value {
3747 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3748 "prefix" => Ok(GeneratedField::Prefix),
3749 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3750 "limit" => Ok(GeneratedField::Limit),
3751 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3752 }
3753 }
3754 }
3755 deserializer.deserialize_identifier(GeneratedVisitor)
3756 }
3757 }
3758 struct GeneratedVisitor;
3759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3760 type Value = FullScanTask;
3761
3762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3763 formatter.write_str("struct hummock.FullScanTask")
3764 }
3765
3766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3767 where
3768 V: serde::de::MapAccess<'de>,
3769 {
3770 let mut sst_retention_watermark__ = None;
3771 let mut prefix__ = None;
3772 let mut start_after__ = None;
3773 let mut limit__ = None;
3774 while let Some(k) = map_.next_key()? {
3775 match k {
3776 GeneratedField::SstRetentionWatermark => {
3777 if sst_retention_watermark__.is_some() {
3778 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3779 }
3780 sst_retention_watermark__ =
3781 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3782 ;
3783 }
3784 GeneratedField::Prefix => {
3785 if prefix__.is_some() {
3786 return Err(serde::de::Error::duplicate_field("prefix"));
3787 }
3788 prefix__ = map_.next_value()?;
3789 }
3790 GeneratedField::StartAfter => {
3791 if start_after__.is_some() {
3792 return Err(serde::de::Error::duplicate_field("startAfter"));
3793 }
3794 start_after__ = map_.next_value()?;
3795 }
3796 GeneratedField::Limit => {
3797 if limit__.is_some() {
3798 return Err(serde::de::Error::duplicate_field("limit"));
3799 }
3800 limit__ =
3801 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3802 ;
3803 }
3804 }
3805 }
3806 Ok(FullScanTask {
3807 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3808 prefix: prefix__,
3809 start_after: start_after__,
3810 limit: limit__,
3811 })
3812 }
3813 }
3814 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3815 }
3816}
3817impl serde::Serialize for GetAssignedCompactTaskNumRequest {
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 len = 0;
3825 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3826 struct_ser.end()
3827 }
3828}
3829impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3830 #[allow(deprecated)]
3831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3832 where
3833 D: serde::Deserializer<'de>,
3834 {
3835 const FIELDS: &[&str] = &[
3836 ];
3837
3838 #[allow(clippy::enum_variant_names)]
3839 enum GeneratedField {
3840 }
3841 impl<'de> serde::Deserialize<'de> for GeneratedField {
3842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3843 where
3844 D: serde::Deserializer<'de>,
3845 {
3846 struct GeneratedVisitor;
3847
3848 impl serde::de::Visitor<'_> for GeneratedVisitor {
3849 type Value = GeneratedField;
3850
3851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3852 write!(formatter, "expected one of: {:?}", &FIELDS)
3853 }
3854
3855 #[allow(unused_variables)]
3856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3857 where
3858 E: serde::de::Error,
3859 {
3860 Err(serde::de::Error::unknown_field(value, FIELDS))
3861 }
3862 }
3863 deserializer.deserialize_identifier(GeneratedVisitor)
3864 }
3865 }
3866 struct GeneratedVisitor;
3867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3868 type Value = GetAssignedCompactTaskNumRequest;
3869
3870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3871 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3872 }
3873
3874 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3875 where
3876 V: serde::de::MapAccess<'de>,
3877 {
3878 while map_.next_key::<GeneratedField>()?.is_some() {
3879 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3880 }
3881 Ok(GetAssignedCompactTaskNumRequest {
3882 })
3883 }
3884 }
3885 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3886 }
3887}
3888impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3889 #[allow(deprecated)]
3890 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3891 where
3892 S: serde::Serializer,
3893 {
3894 use serde::ser::SerializeStruct;
3895 let mut len = 0;
3896 if self.num_tasks != 0 {
3897 len += 1;
3898 }
3899 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3900 if self.num_tasks != 0 {
3901 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3902 }
3903 struct_ser.end()
3904 }
3905}
3906impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3907 #[allow(deprecated)]
3908 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3909 where
3910 D: serde::Deserializer<'de>,
3911 {
3912 const FIELDS: &[&str] = &[
3913 "num_tasks",
3914 "numTasks",
3915 ];
3916
3917 #[allow(clippy::enum_variant_names)]
3918 enum GeneratedField {
3919 NumTasks,
3920 }
3921 impl<'de> serde::Deserialize<'de> for GeneratedField {
3922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3923 where
3924 D: serde::Deserializer<'de>,
3925 {
3926 struct GeneratedVisitor;
3927
3928 impl serde::de::Visitor<'_> for GeneratedVisitor {
3929 type Value = GeneratedField;
3930
3931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3932 write!(formatter, "expected one of: {:?}", &FIELDS)
3933 }
3934
3935 #[allow(unused_variables)]
3936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3937 where
3938 E: serde::de::Error,
3939 {
3940 match value {
3941 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3943 }
3944 }
3945 }
3946 deserializer.deserialize_identifier(GeneratedVisitor)
3947 }
3948 }
3949 struct GeneratedVisitor;
3950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3951 type Value = GetAssignedCompactTaskNumResponse;
3952
3953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3954 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3955 }
3956
3957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3958 where
3959 V: serde::de::MapAccess<'de>,
3960 {
3961 let mut num_tasks__ = None;
3962 while let Some(k) = map_.next_key()? {
3963 match k {
3964 GeneratedField::NumTasks => {
3965 if num_tasks__.is_some() {
3966 return Err(serde::de::Error::duplicate_field("numTasks"));
3967 }
3968 num_tasks__ =
3969 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3970 ;
3971 }
3972 }
3973 }
3974 Ok(GetAssignedCompactTaskNumResponse {
3975 num_tasks: num_tasks__.unwrap_or_default(),
3976 })
3977 }
3978 }
3979 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3980 }
3981}
3982impl serde::Serialize for GetCompactionScoreRequest {
3983 #[allow(deprecated)]
3984 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3985 where
3986 S: serde::Serializer,
3987 {
3988 use serde::ser::SerializeStruct;
3989 let mut len = 0;
3990 if self.compaction_group_id != 0 {
3991 len += 1;
3992 }
3993 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3994 if self.compaction_group_id != 0 {
3995 #[allow(clippy::needless_borrow)]
3996 #[allow(clippy::needless_borrows_for_generic_args)]
3997 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3998 }
3999 struct_ser.end()
4000 }
4001}
4002impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
4003 #[allow(deprecated)]
4004 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4005 where
4006 D: serde::Deserializer<'de>,
4007 {
4008 const FIELDS: &[&str] = &[
4009 "compaction_group_id",
4010 "compactionGroupId",
4011 ];
4012
4013 #[allow(clippy::enum_variant_names)]
4014 enum GeneratedField {
4015 CompactionGroupId,
4016 }
4017 impl<'de> serde::Deserialize<'de> for GeneratedField {
4018 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4019 where
4020 D: serde::Deserializer<'de>,
4021 {
4022 struct GeneratedVisitor;
4023
4024 impl serde::de::Visitor<'_> for GeneratedVisitor {
4025 type Value = GeneratedField;
4026
4027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4028 write!(formatter, "expected one of: {:?}", &FIELDS)
4029 }
4030
4031 #[allow(unused_variables)]
4032 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4033 where
4034 E: serde::de::Error,
4035 {
4036 match value {
4037 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
4038 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4039 }
4040 }
4041 }
4042 deserializer.deserialize_identifier(GeneratedVisitor)
4043 }
4044 }
4045 struct GeneratedVisitor;
4046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4047 type Value = GetCompactionScoreRequest;
4048
4049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4050 formatter.write_str("struct hummock.GetCompactionScoreRequest")
4051 }
4052
4053 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
4054 where
4055 V: serde::de::MapAccess<'de>,
4056 {
4057 let mut compaction_group_id__ = None;
4058 while let Some(k) = map_.next_key()? {
4059 match k {
4060 GeneratedField::CompactionGroupId => {
4061 if compaction_group_id__.is_some() {
4062 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
4063 }
4064 compaction_group_id__ =
4065 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4066 ;
4067 }
4068 }
4069 }
4070 Ok(GetCompactionScoreRequest {
4071 compaction_group_id: compaction_group_id__.unwrap_or_default(),
4072 })
4073 }
4074 }
4075 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
4076 }
4077}
4078impl serde::Serialize for GetCompactionScoreResponse {
4079 #[allow(deprecated)]
4080 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4081 where
4082 S: serde::Serializer,
4083 {
4084 use serde::ser::SerializeStruct;
4085 let mut len = 0;
4086 if self.compaction_group_id != 0 {
4087 len += 1;
4088 }
4089 if !self.scores.is_empty() {
4090 len += 1;
4091 }
4092 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
4093 if self.compaction_group_id != 0 {
4094 #[allow(clippy::needless_borrow)]
4095 #[allow(clippy::needless_borrows_for_generic_args)]
4096 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
4097 }
4098 if !self.scores.is_empty() {
4099 struct_ser.serialize_field("scores", &self.scores)?;
4100 }
4101 struct_ser.end()
4102 }
4103}
4104impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
4105 #[allow(deprecated)]
4106 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4107 where
4108 D: serde::Deserializer<'de>,
4109 {
4110 const FIELDS: &[&str] = &[
4111 "compaction_group_id",
4112 "compactionGroupId",
4113 "scores",
4114 ];
4115
4116 #[allow(clippy::enum_variant_names)]
4117 enum GeneratedField {
4118 CompactionGroupId,
4119 Scores,
4120 }
4121 impl<'de> serde::Deserialize<'de> for GeneratedField {
4122 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4123 where
4124 D: serde::Deserializer<'de>,
4125 {
4126 struct GeneratedVisitor;
4127
4128 impl serde::de::Visitor<'_> for GeneratedVisitor {
4129 type Value = GeneratedField;
4130
4131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4132 write!(formatter, "expected one of: {:?}", &FIELDS)
4133 }
4134
4135 #[allow(unused_variables)]
4136 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4137 where
4138 E: serde::de::Error,
4139 {
4140 match value {
4141 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
4142 "scores" => Ok(GeneratedField::Scores),
4143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4144 }
4145 }
4146 }
4147 deserializer.deserialize_identifier(GeneratedVisitor)
4148 }
4149 }
4150 struct GeneratedVisitor;
4151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4152 type Value = GetCompactionScoreResponse;
4153
4154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4155 formatter.write_str("struct hummock.GetCompactionScoreResponse")
4156 }
4157
4158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
4159 where
4160 V: serde::de::MapAccess<'de>,
4161 {
4162 let mut compaction_group_id__ = None;
4163 let mut scores__ = None;
4164 while let Some(k) = map_.next_key()? {
4165 match k {
4166 GeneratedField::CompactionGroupId => {
4167 if compaction_group_id__.is_some() {
4168 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
4169 }
4170 compaction_group_id__ =
4171 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4172 ;
4173 }
4174 GeneratedField::Scores => {
4175 if scores__.is_some() {
4176 return Err(serde::de::Error::duplicate_field("scores"));
4177 }
4178 scores__ = Some(map_.next_value()?);
4179 }
4180 }
4181 }
4182 Ok(GetCompactionScoreResponse {
4183 compaction_group_id: compaction_group_id__.unwrap_or_default(),
4184 scores: scores__.unwrap_or_default(),
4185 })
4186 }
4187 }
4188 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
4189 }
4190}
4191impl serde::Serialize for get_compaction_score_response::PickerInfo {
4192 #[allow(deprecated)]
4193 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4194 where
4195 S: serde::Serializer,
4196 {
4197 use serde::ser::SerializeStruct;
4198 let mut len = 0;
4199 if self.score != 0 {
4200 len += 1;
4201 }
4202 if self.select_level != 0 {
4203 len += 1;
4204 }
4205 if self.target_level != 0 {
4206 len += 1;
4207 }
4208 if !self.picker_type.is_empty() {
4209 len += 1;
4210 }
4211 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
4212 if self.score != 0 {
4213 #[allow(clippy::needless_borrow)]
4214 #[allow(clippy::needless_borrows_for_generic_args)]
4215 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
4216 }
4217 if self.select_level != 0 {
4218 #[allow(clippy::needless_borrow)]
4219 #[allow(clippy::needless_borrows_for_generic_args)]
4220 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
4221 }
4222 if self.target_level != 0 {
4223 #[allow(clippy::needless_borrow)]
4224 #[allow(clippy::needless_borrows_for_generic_args)]
4225 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
4226 }
4227 if !self.picker_type.is_empty() {
4228 struct_ser.serialize_field("pickerType", &self.picker_type)?;
4229 }
4230 struct_ser.end()
4231 }
4232}
4233impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
4234 #[allow(deprecated)]
4235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4236 where
4237 D: serde::Deserializer<'de>,
4238 {
4239 const FIELDS: &[&str] = &[
4240 "score",
4241 "select_level",
4242 "selectLevel",
4243 "target_level",
4244 "targetLevel",
4245 "picker_type",
4246 "pickerType",
4247 ];
4248
4249 #[allow(clippy::enum_variant_names)]
4250 enum GeneratedField {
4251 Score,
4252 SelectLevel,
4253 TargetLevel,
4254 PickerType,
4255 }
4256 impl<'de> serde::Deserialize<'de> for GeneratedField {
4257 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4258 where
4259 D: serde::Deserializer<'de>,
4260 {
4261 struct GeneratedVisitor;
4262
4263 impl serde::de::Visitor<'_> for GeneratedVisitor {
4264 type Value = GeneratedField;
4265
4266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4267 write!(formatter, "expected one of: {:?}", &FIELDS)
4268 }
4269
4270 #[allow(unused_variables)]
4271 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4272 where
4273 E: serde::de::Error,
4274 {
4275 match value {
4276 "score" => Ok(GeneratedField::Score),
4277 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4278 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4279 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4280 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4281 }
4282 }
4283 }
4284 deserializer.deserialize_identifier(GeneratedVisitor)
4285 }
4286 }
4287 struct GeneratedVisitor;
4288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4289 type Value = get_compaction_score_response::PickerInfo;
4290
4291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4292 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4293 }
4294
4295 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4296 where
4297 V: serde::de::MapAccess<'de>,
4298 {
4299 let mut score__ = None;
4300 let mut select_level__ = None;
4301 let mut target_level__ = None;
4302 let mut picker_type__ = None;
4303 while let Some(k) = map_.next_key()? {
4304 match k {
4305 GeneratedField::Score => {
4306 if score__.is_some() {
4307 return Err(serde::de::Error::duplicate_field("score"));
4308 }
4309 score__ =
4310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4311 ;
4312 }
4313 GeneratedField::SelectLevel => {
4314 if select_level__.is_some() {
4315 return Err(serde::de::Error::duplicate_field("selectLevel"));
4316 }
4317 select_level__ =
4318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4319 ;
4320 }
4321 GeneratedField::TargetLevel => {
4322 if target_level__.is_some() {
4323 return Err(serde::de::Error::duplicate_field("targetLevel"));
4324 }
4325 target_level__ =
4326 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4327 ;
4328 }
4329 GeneratedField::PickerType => {
4330 if picker_type__.is_some() {
4331 return Err(serde::de::Error::duplicate_field("pickerType"));
4332 }
4333 picker_type__ = Some(map_.next_value()?);
4334 }
4335 }
4336 }
4337 Ok(get_compaction_score_response::PickerInfo {
4338 score: score__.unwrap_or_default(),
4339 select_level: select_level__.unwrap_or_default(),
4340 target_level: target_level__.unwrap_or_default(),
4341 picker_type: picker_type__.unwrap_or_default(),
4342 })
4343 }
4344 }
4345 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4346 }
4347}
4348impl serde::Serialize for GetCurrentVersionRequest {
4349 #[allow(deprecated)]
4350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4351 where
4352 S: serde::Serializer,
4353 {
4354 use serde::ser::SerializeStruct;
4355 let len = 0;
4356 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4357 struct_ser.end()
4358 }
4359}
4360impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4361 #[allow(deprecated)]
4362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4363 where
4364 D: serde::Deserializer<'de>,
4365 {
4366 const FIELDS: &[&str] = &[
4367 ];
4368
4369 #[allow(clippy::enum_variant_names)]
4370 enum GeneratedField {
4371 }
4372 impl<'de> serde::Deserialize<'de> for GeneratedField {
4373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4374 where
4375 D: serde::Deserializer<'de>,
4376 {
4377 struct GeneratedVisitor;
4378
4379 impl serde::de::Visitor<'_> for GeneratedVisitor {
4380 type Value = GeneratedField;
4381
4382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4383 write!(formatter, "expected one of: {:?}", &FIELDS)
4384 }
4385
4386 #[allow(unused_variables)]
4387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4388 where
4389 E: serde::de::Error,
4390 {
4391 Err(serde::de::Error::unknown_field(value, FIELDS))
4392 }
4393 }
4394 deserializer.deserialize_identifier(GeneratedVisitor)
4395 }
4396 }
4397 struct GeneratedVisitor;
4398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4399 type Value = GetCurrentVersionRequest;
4400
4401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4402 formatter.write_str("struct hummock.GetCurrentVersionRequest")
4403 }
4404
4405 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4406 where
4407 V: serde::de::MapAccess<'de>,
4408 {
4409 while map_.next_key::<GeneratedField>()?.is_some() {
4410 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4411 }
4412 Ok(GetCurrentVersionRequest {
4413 })
4414 }
4415 }
4416 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4417 }
4418}
4419impl serde::Serialize for GetCurrentVersionResponse {
4420 #[allow(deprecated)]
4421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4422 where
4423 S: serde::Serializer,
4424 {
4425 use serde::ser::SerializeStruct;
4426 let mut len = 0;
4427 if self.status.is_some() {
4428 len += 1;
4429 }
4430 if self.current_version.is_some() {
4431 len += 1;
4432 }
4433 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4434 if let Some(v) = self.status.as_ref() {
4435 struct_ser.serialize_field("status", v)?;
4436 }
4437 if let Some(v) = self.current_version.as_ref() {
4438 struct_ser.serialize_field("currentVersion", v)?;
4439 }
4440 struct_ser.end()
4441 }
4442}
4443impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4444 #[allow(deprecated)]
4445 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4446 where
4447 D: serde::Deserializer<'de>,
4448 {
4449 const FIELDS: &[&str] = &[
4450 "status",
4451 "current_version",
4452 "currentVersion",
4453 ];
4454
4455 #[allow(clippy::enum_variant_names)]
4456 enum GeneratedField {
4457 Status,
4458 CurrentVersion,
4459 }
4460 impl<'de> serde::Deserialize<'de> for GeneratedField {
4461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4462 where
4463 D: serde::Deserializer<'de>,
4464 {
4465 struct GeneratedVisitor;
4466
4467 impl serde::de::Visitor<'_> for GeneratedVisitor {
4468 type Value = GeneratedField;
4469
4470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4471 write!(formatter, "expected one of: {:?}", &FIELDS)
4472 }
4473
4474 #[allow(unused_variables)]
4475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4476 where
4477 E: serde::de::Error,
4478 {
4479 match value {
4480 "status" => Ok(GeneratedField::Status),
4481 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4482 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4483 }
4484 }
4485 }
4486 deserializer.deserialize_identifier(GeneratedVisitor)
4487 }
4488 }
4489 struct GeneratedVisitor;
4490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4491 type Value = GetCurrentVersionResponse;
4492
4493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4494 formatter.write_str("struct hummock.GetCurrentVersionResponse")
4495 }
4496
4497 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4498 where
4499 V: serde::de::MapAccess<'de>,
4500 {
4501 let mut status__ = None;
4502 let mut current_version__ = None;
4503 while let Some(k) = map_.next_key()? {
4504 match k {
4505 GeneratedField::Status => {
4506 if status__.is_some() {
4507 return Err(serde::de::Error::duplicate_field("status"));
4508 }
4509 status__ = map_.next_value()?;
4510 }
4511 GeneratedField::CurrentVersion => {
4512 if current_version__.is_some() {
4513 return Err(serde::de::Error::duplicate_field("currentVersion"));
4514 }
4515 current_version__ = map_.next_value()?;
4516 }
4517 }
4518 }
4519 Ok(GetCurrentVersionResponse {
4520 status: status__,
4521 current_version: current_version__,
4522 })
4523 }
4524 }
4525 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4526 }
4527}
4528impl serde::Serialize for GetNewObjectIdsRequest {
4529 #[allow(deprecated)]
4530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4531 where
4532 S: serde::Serializer,
4533 {
4534 use serde::ser::SerializeStruct;
4535 let mut len = 0;
4536 if self.number != 0 {
4537 len += 1;
4538 }
4539 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4540 if self.number != 0 {
4541 struct_ser.serialize_field("number", &self.number)?;
4542 }
4543 struct_ser.end()
4544 }
4545}
4546impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4547 #[allow(deprecated)]
4548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4549 where
4550 D: serde::Deserializer<'de>,
4551 {
4552 const FIELDS: &[&str] = &[
4553 "number",
4554 ];
4555
4556 #[allow(clippy::enum_variant_names)]
4557 enum GeneratedField {
4558 Number,
4559 }
4560 impl<'de> serde::Deserialize<'de> for GeneratedField {
4561 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4562 where
4563 D: serde::Deserializer<'de>,
4564 {
4565 struct GeneratedVisitor;
4566
4567 impl serde::de::Visitor<'_> for GeneratedVisitor {
4568 type Value = GeneratedField;
4569
4570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4571 write!(formatter, "expected one of: {:?}", &FIELDS)
4572 }
4573
4574 #[allow(unused_variables)]
4575 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4576 where
4577 E: serde::de::Error,
4578 {
4579 match value {
4580 "number" => Ok(GeneratedField::Number),
4581 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4582 }
4583 }
4584 }
4585 deserializer.deserialize_identifier(GeneratedVisitor)
4586 }
4587 }
4588 struct GeneratedVisitor;
4589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4590 type Value = GetNewObjectIdsRequest;
4591
4592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4593 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4594 }
4595
4596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4597 where
4598 V: serde::de::MapAccess<'de>,
4599 {
4600 let mut number__ = None;
4601 while let Some(k) = map_.next_key()? {
4602 match k {
4603 GeneratedField::Number => {
4604 if number__.is_some() {
4605 return Err(serde::de::Error::duplicate_field("number"));
4606 }
4607 number__ =
4608 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4609 ;
4610 }
4611 }
4612 }
4613 Ok(GetNewObjectIdsRequest {
4614 number: number__.unwrap_or_default(),
4615 })
4616 }
4617 }
4618 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4619 }
4620}
4621impl serde::Serialize for GetNewObjectIdsResponse {
4622 #[allow(deprecated)]
4623 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4624 where
4625 S: serde::Serializer,
4626 {
4627 use serde::ser::SerializeStruct;
4628 let mut len = 0;
4629 if self.status.is_some() {
4630 len += 1;
4631 }
4632 if self.start_id != 0 {
4633 len += 1;
4634 }
4635 if self.end_id != 0 {
4636 len += 1;
4637 }
4638 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4639 if let Some(v) = self.status.as_ref() {
4640 struct_ser.serialize_field("status", v)?;
4641 }
4642 if self.start_id != 0 {
4643 #[allow(clippy::needless_borrow)]
4644 #[allow(clippy::needless_borrows_for_generic_args)]
4645 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4646 }
4647 if self.end_id != 0 {
4648 #[allow(clippy::needless_borrow)]
4649 #[allow(clippy::needless_borrows_for_generic_args)]
4650 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4651 }
4652 struct_ser.end()
4653 }
4654}
4655impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4656 #[allow(deprecated)]
4657 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4658 where
4659 D: serde::Deserializer<'de>,
4660 {
4661 const FIELDS: &[&str] = &[
4662 "status",
4663 "start_id",
4664 "startId",
4665 "end_id",
4666 "endId",
4667 ];
4668
4669 #[allow(clippy::enum_variant_names)]
4670 enum GeneratedField {
4671 Status,
4672 StartId,
4673 EndId,
4674 }
4675 impl<'de> serde::Deserialize<'de> for GeneratedField {
4676 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4677 where
4678 D: serde::Deserializer<'de>,
4679 {
4680 struct GeneratedVisitor;
4681
4682 impl serde::de::Visitor<'_> for GeneratedVisitor {
4683 type Value = GeneratedField;
4684
4685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4686 write!(formatter, "expected one of: {:?}", &FIELDS)
4687 }
4688
4689 #[allow(unused_variables)]
4690 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4691 where
4692 E: serde::de::Error,
4693 {
4694 match value {
4695 "status" => Ok(GeneratedField::Status),
4696 "startId" | "start_id" => Ok(GeneratedField::StartId),
4697 "endId" | "end_id" => Ok(GeneratedField::EndId),
4698 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4699 }
4700 }
4701 }
4702 deserializer.deserialize_identifier(GeneratedVisitor)
4703 }
4704 }
4705 struct GeneratedVisitor;
4706 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4707 type Value = GetNewObjectIdsResponse;
4708
4709 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4710 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4711 }
4712
4713 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4714 where
4715 V: serde::de::MapAccess<'de>,
4716 {
4717 let mut status__ = None;
4718 let mut start_id__ = None;
4719 let mut end_id__ = None;
4720 while let Some(k) = map_.next_key()? {
4721 match k {
4722 GeneratedField::Status => {
4723 if status__.is_some() {
4724 return Err(serde::de::Error::duplicate_field("status"));
4725 }
4726 status__ = map_.next_value()?;
4727 }
4728 GeneratedField::StartId => {
4729 if start_id__.is_some() {
4730 return Err(serde::de::Error::duplicate_field("startId"));
4731 }
4732 start_id__ =
4733 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4734 ;
4735 }
4736 GeneratedField::EndId => {
4737 if end_id__.is_some() {
4738 return Err(serde::de::Error::duplicate_field("endId"));
4739 }
4740 end_id__ =
4741 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4742 ;
4743 }
4744 }
4745 }
4746 Ok(GetNewObjectIdsResponse {
4747 status: status__,
4748 start_id: start_id__.unwrap_or_default(),
4749 end_id: end_id__.unwrap_or_default(),
4750 })
4751 }
4752 }
4753 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4754 }
4755}
4756impl serde::Serialize for GetTableChangeLogsRequest {
4757 #[allow(deprecated)]
4758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4759 where
4760 S: serde::Serializer,
4761 {
4762 use serde::ser::SerializeStruct;
4763 let mut len = 0;
4764 if self.epoch_only {
4765 len += 1;
4766 }
4767 if self.exclude_empty {
4768 len += 1;
4769 }
4770 if self.start_epoch_inclusive.is_some() {
4771 len += 1;
4772 }
4773 if self.end_epoch_inclusive.is_some() {
4774 len += 1;
4775 }
4776 if self.table_ids.is_some() {
4777 len += 1;
4778 }
4779 if self.limit.is_some() {
4780 len += 1;
4781 }
4782 let mut struct_ser = serializer.serialize_struct("hummock.GetTableChangeLogsRequest", len)?;
4783 if self.epoch_only {
4784 struct_ser.serialize_field("epochOnly", &self.epoch_only)?;
4785 }
4786 if self.exclude_empty {
4787 struct_ser.serialize_field("excludeEmpty", &self.exclude_empty)?;
4788 }
4789 if let Some(v) = self.start_epoch_inclusive.as_ref() {
4790 #[allow(clippy::needless_borrow)]
4791 #[allow(clippy::needless_borrows_for_generic_args)]
4792 struct_ser.serialize_field("startEpochInclusive", ToString::to_string(&v).as_str())?;
4793 }
4794 if let Some(v) = self.end_epoch_inclusive.as_ref() {
4795 #[allow(clippy::needless_borrow)]
4796 #[allow(clippy::needless_borrows_for_generic_args)]
4797 struct_ser.serialize_field("endEpochInclusive", ToString::to_string(&v).as_str())?;
4798 }
4799 if let Some(v) = self.table_ids.as_ref() {
4800 struct_ser.serialize_field("tableIds", v)?;
4801 }
4802 if let Some(v) = self.limit.as_ref() {
4803 struct_ser.serialize_field("limit", v)?;
4804 }
4805 struct_ser.end()
4806 }
4807}
4808impl<'de> serde::Deserialize<'de> for GetTableChangeLogsRequest {
4809 #[allow(deprecated)]
4810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4811 where
4812 D: serde::Deserializer<'de>,
4813 {
4814 const FIELDS: &[&str] = &[
4815 "epoch_only",
4816 "epochOnly",
4817 "exclude_empty",
4818 "excludeEmpty",
4819 "start_epoch_inclusive",
4820 "startEpochInclusive",
4821 "end_epoch_inclusive",
4822 "endEpochInclusive",
4823 "table_ids",
4824 "tableIds",
4825 "limit",
4826 ];
4827
4828 #[allow(clippy::enum_variant_names)]
4829 enum GeneratedField {
4830 EpochOnly,
4831 ExcludeEmpty,
4832 StartEpochInclusive,
4833 EndEpochInclusive,
4834 TableIds,
4835 Limit,
4836 }
4837 impl<'de> serde::Deserialize<'de> for GeneratedField {
4838 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4839 where
4840 D: serde::Deserializer<'de>,
4841 {
4842 struct GeneratedVisitor;
4843
4844 impl serde::de::Visitor<'_> for GeneratedVisitor {
4845 type Value = GeneratedField;
4846
4847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4848 write!(formatter, "expected one of: {:?}", &FIELDS)
4849 }
4850
4851 #[allow(unused_variables)]
4852 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4853 where
4854 E: serde::de::Error,
4855 {
4856 match value {
4857 "epochOnly" | "epoch_only" => Ok(GeneratedField::EpochOnly),
4858 "excludeEmpty" | "exclude_empty" => Ok(GeneratedField::ExcludeEmpty),
4859 "startEpochInclusive" | "start_epoch_inclusive" => Ok(GeneratedField::StartEpochInclusive),
4860 "endEpochInclusive" | "end_epoch_inclusive" => Ok(GeneratedField::EndEpochInclusive),
4861 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4862 "limit" => Ok(GeneratedField::Limit),
4863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4864 }
4865 }
4866 }
4867 deserializer.deserialize_identifier(GeneratedVisitor)
4868 }
4869 }
4870 struct GeneratedVisitor;
4871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4872 type Value = GetTableChangeLogsRequest;
4873
4874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4875 formatter.write_str("struct hummock.GetTableChangeLogsRequest")
4876 }
4877
4878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableChangeLogsRequest, V::Error>
4879 where
4880 V: serde::de::MapAccess<'de>,
4881 {
4882 let mut epoch_only__ = None;
4883 let mut exclude_empty__ = None;
4884 let mut start_epoch_inclusive__ = None;
4885 let mut end_epoch_inclusive__ = None;
4886 let mut table_ids__ = None;
4887 let mut limit__ = None;
4888 while let Some(k) = map_.next_key()? {
4889 match k {
4890 GeneratedField::EpochOnly => {
4891 if epoch_only__.is_some() {
4892 return Err(serde::de::Error::duplicate_field("epochOnly"));
4893 }
4894 epoch_only__ = Some(map_.next_value()?);
4895 }
4896 GeneratedField::ExcludeEmpty => {
4897 if exclude_empty__.is_some() {
4898 return Err(serde::de::Error::duplicate_field("excludeEmpty"));
4899 }
4900 exclude_empty__ = Some(map_.next_value()?);
4901 }
4902 GeneratedField::StartEpochInclusive => {
4903 if start_epoch_inclusive__.is_some() {
4904 return Err(serde::de::Error::duplicate_field("startEpochInclusive"));
4905 }
4906 start_epoch_inclusive__ =
4907 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4908 ;
4909 }
4910 GeneratedField::EndEpochInclusive => {
4911 if end_epoch_inclusive__.is_some() {
4912 return Err(serde::de::Error::duplicate_field("endEpochInclusive"));
4913 }
4914 end_epoch_inclusive__ =
4915 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4916 ;
4917 }
4918 GeneratedField::TableIds => {
4919 if table_ids__.is_some() {
4920 return Err(serde::de::Error::duplicate_field("tableIds"));
4921 }
4922 table_ids__ = map_.next_value()?;
4923 }
4924 GeneratedField::Limit => {
4925 if limit__.is_some() {
4926 return Err(serde::de::Error::duplicate_field("limit"));
4927 }
4928 limit__ =
4929 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4930 ;
4931 }
4932 }
4933 }
4934 Ok(GetTableChangeLogsRequest {
4935 epoch_only: epoch_only__.unwrap_or_default(),
4936 exclude_empty: exclude_empty__.unwrap_or_default(),
4937 start_epoch_inclusive: start_epoch_inclusive__,
4938 end_epoch_inclusive: end_epoch_inclusive__,
4939 table_ids: table_ids__,
4940 limit: limit__,
4941 })
4942 }
4943 }
4944 deserializer.deserialize_struct("hummock.GetTableChangeLogsRequest", FIELDS, GeneratedVisitor)
4945 }
4946}
4947impl serde::Serialize for get_table_change_logs_request::TableFilter {
4948 #[allow(deprecated)]
4949 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4950 where
4951 S: serde::Serializer,
4952 {
4953 use serde::ser::SerializeStruct;
4954 let mut len = 0;
4955 if !self.table_ids.is_empty() {
4956 len += 1;
4957 }
4958 let mut struct_ser = serializer.serialize_struct("hummock.GetTableChangeLogsRequest.TableFilter", len)?;
4959 if !self.table_ids.is_empty() {
4960 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4961 }
4962 struct_ser.end()
4963 }
4964}
4965impl<'de> serde::Deserialize<'de> for get_table_change_logs_request::TableFilter {
4966 #[allow(deprecated)]
4967 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4968 where
4969 D: serde::Deserializer<'de>,
4970 {
4971 const FIELDS: &[&str] = &[
4972 "table_ids",
4973 "tableIds",
4974 ];
4975
4976 #[allow(clippy::enum_variant_names)]
4977 enum GeneratedField {
4978 TableIds,
4979 }
4980 impl<'de> serde::Deserialize<'de> for GeneratedField {
4981 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4982 where
4983 D: serde::Deserializer<'de>,
4984 {
4985 struct GeneratedVisitor;
4986
4987 impl serde::de::Visitor<'_> for GeneratedVisitor {
4988 type Value = GeneratedField;
4989
4990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4991 write!(formatter, "expected one of: {:?}", &FIELDS)
4992 }
4993
4994 #[allow(unused_variables)]
4995 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4996 where
4997 E: serde::de::Error,
4998 {
4999 match value {
5000 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
5001 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5002 }
5003 }
5004 }
5005 deserializer.deserialize_identifier(GeneratedVisitor)
5006 }
5007 }
5008 struct GeneratedVisitor;
5009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5010 type Value = get_table_change_logs_request::TableFilter;
5011
5012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5013 formatter.write_str("struct hummock.GetTableChangeLogsRequest.TableFilter")
5014 }
5015
5016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_table_change_logs_request::TableFilter, V::Error>
5017 where
5018 V: serde::de::MapAccess<'de>,
5019 {
5020 let mut table_ids__ = None;
5021 while let Some(k) = map_.next_key()? {
5022 match k {
5023 GeneratedField::TableIds => {
5024 if table_ids__.is_some() {
5025 return Err(serde::de::Error::duplicate_field("tableIds"));
5026 }
5027 table_ids__ =
5028 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5029 .into_iter().map(|x| x.0).collect())
5030 ;
5031 }
5032 }
5033 }
5034 Ok(get_table_change_logs_request::TableFilter {
5035 table_ids: table_ids__.unwrap_or_default(),
5036 })
5037 }
5038 }
5039 deserializer.deserialize_struct("hummock.GetTableChangeLogsRequest.TableFilter", FIELDS, GeneratedVisitor)
5040 }
5041}
5042impl serde::Serialize for GetTableChangeLogsResponse {
5043 #[allow(deprecated)]
5044 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5045 where
5046 S: serde::Serializer,
5047 {
5048 use serde::ser::SerializeStruct;
5049 let mut len = 0;
5050 if !self.table_change_logs.is_empty() {
5051 len += 1;
5052 }
5053 let mut struct_ser = serializer.serialize_struct("hummock.GetTableChangeLogsResponse", len)?;
5054 if !self.table_change_logs.is_empty() {
5055 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
5056 }
5057 struct_ser.end()
5058 }
5059}
5060impl<'de> serde::Deserialize<'de> for GetTableChangeLogsResponse {
5061 #[allow(deprecated)]
5062 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5063 where
5064 D: serde::Deserializer<'de>,
5065 {
5066 const FIELDS: &[&str] = &[
5067 "table_change_logs",
5068 "tableChangeLogs",
5069 ];
5070
5071 #[allow(clippy::enum_variant_names)]
5072 enum GeneratedField {
5073 TableChangeLogs,
5074 }
5075 impl<'de> serde::Deserialize<'de> for GeneratedField {
5076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5077 where
5078 D: serde::Deserializer<'de>,
5079 {
5080 struct GeneratedVisitor;
5081
5082 impl serde::de::Visitor<'_> for GeneratedVisitor {
5083 type Value = GeneratedField;
5084
5085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5086 write!(formatter, "expected one of: {:?}", &FIELDS)
5087 }
5088
5089 #[allow(unused_variables)]
5090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5091 where
5092 E: serde::de::Error,
5093 {
5094 match value {
5095 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
5096 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5097 }
5098 }
5099 }
5100 deserializer.deserialize_identifier(GeneratedVisitor)
5101 }
5102 }
5103 struct GeneratedVisitor;
5104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5105 type Value = GetTableChangeLogsResponse;
5106
5107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5108 formatter.write_str("struct hummock.GetTableChangeLogsResponse")
5109 }
5110
5111 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableChangeLogsResponse, V::Error>
5112 where
5113 V: serde::de::MapAccess<'de>,
5114 {
5115 let mut table_change_logs__ = None;
5116 while let Some(k) = map_.next_key()? {
5117 match k {
5118 GeneratedField::TableChangeLogs => {
5119 if table_change_logs__.is_some() {
5120 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
5121 }
5122 table_change_logs__ = Some(
5123 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5124 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5125 );
5126 }
5127 }
5128 }
5129 Ok(GetTableChangeLogsResponse {
5130 table_change_logs: table_change_logs__.unwrap_or_default(),
5131 })
5132 }
5133 }
5134 deserializer.deserialize_struct("hummock.GetTableChangeLogsResponse", FIELDS, GeneratedVisitor)
5135 }
5136}
5137impl serde::Serialize for GetVersionByEpochRequest {
5138 #[allow(deprecated)]
5139 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5140 where
5141 S: serde::Serializer,
5142 {
5143 use serde::ser::SerializeStruct;
5144 let mut len = 0;
5145 if self.epoch != 0 {
5146 len += 1;
5147 }
5148 if self.table_id != 0 {
5149 len += 1;
5150 }
5151 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
5152 if self.epoch != 0 {
5153 #[allow(clippy::needless_borrow)]
5154 #[allow(clippy::needless_borrows_for_generic_args)]
5155 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
5156 }
5157 if self.table_id != 0 {
5158 struct_ser.serialize_field("tableId", &self.table_id)?;
5159 }
5160 struct_ser.end()
5161 }
5162}
5163impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
5164 #[allow(deprecated)]
5165 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5166 where
5167 D: serde::Deserializer<'de>,
5168 {
5169 const FIELDS: &[&str] = &[
5170 "epoch",
5171 "table_id",
5172 "tableId",
5173 ];
5174
5175 #[allow(clippy::enum_variant_names)]
5176 enum GeneratedField {
5177 Epoch,
5178 TableId,
5179 }
5180 impl<'de> serde::Deserialize<'de> for GeneratedField {
5181 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5182 where
5183 D: serde::Deserializer<'de>,
5184 {
5185 struct GeneratedVisitor;
5186
5187 impl serde::de::Visitor<'_> for GeneratedVisitor {
5188 type Value = GeneratedField;
5189
5190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5191 write!(formatter, "expected one of: {:?}", &FIELDS)
5192 }
5193
5194 #[allow(unused_variables)]
5195 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5196 where
5197 E: serde::de::Error,
5198 {
5199 match value {
5200 "epoch" => Ok(GeneratedField::Epoch),
5201 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5202 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5203 }
5204 }
5205 }
5206 deserializer.deserialize_identifier(GeneratedVisitor)
5207 }
5208 }
5209 struct GeneratedVisitor;
5210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5211 type Value = GetVersionByEpochRequest;
5212
5213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5214 formatter.write_str("struct hummock.GetVersionByEpochRequest")
5215 }
5216
5217 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
5218 where
5219 V: serde::de::MapAccess<'de>,
5220 {
5221 let mut epoch__ = None;
5222 let mut table_id__ = None;
5223 while let Some(k) = map_.next_key()? {
5224 match k {
5225 GeneratedField::Epoch => {
5226 if epoch__.is_some() {
5227 return Err(serde::de::Error::duplicate_field("epoch"));
5228 }
5229 epoch__ =
5230 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5231 ;
5232 }
5233 GeneratedField::TableId => {
5234 if table_id__.is_some() {
5235 return Err(serde::de::Error::duplicate_field("tableId"));
5236 }
5237 table_id__ =
5238 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5239 ;
5240 }
5241 }
5242 }
5243 Ok(GetVersionByEpochRequest {
5244 epoch: epoch__.unwrap_or_default(),
5245 table_id: table_id__.unwrap_or_default(),
5246 })
5247 }
5248 }
5249 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
5250 }
5251}
5252impl serde::Serialize for GetVersionByEpochResponse {
5253 #[allow(deprecated)]
5254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5255 where
5256 S: serde::Serializer,
5257 {
5258 use serde::ser::SerializeStruct;
5259 let mut len = 0;
5260 if self.version.is_some() {
5261 len += 1;
5262 }
5263 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
5264 if let Some(v) = self.version.as_ref() {
5265 struct_ser.serialize_field("version", v)?;
5266 }
5267 struct_ser.end()
5268 }
5269}
5270impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
5271 #[allow(deprecated)]
5272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5273 where
5274 D: serde::Deserializer<'de>,
5275 {
5276 const FIELDS: &[&str] = &[
5277 "version",
5278 ];
5279
5280 #[allow(clippy::enum_variant_names)]
5281 enum GeneratedField {
5282 Version,
5283 }
5284 impl<'de> serde::Deserialize<'de> for GeneratedField {
5285 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5286 where
5287 D: serde::Deserializer<'de>,
5288 {
5289 struct GeneratedVisitor;
5290
5291 impl serde::de::Visitor<'_> for GeneratedVisitor {
5292 type Value = GeneratedField;
5293
5294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5295 write!(formatter, "expected one of: {:?}", &FIELDS)
5296 }
5297
5298 #[allow(unused_variables)]
5299 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5300 where
5301 E: serde::de::Error,
5302 {
5303 match value {
5304 "version" => Ok(GeneratedField::Version),
5305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5306 }
5307 }
5308 }
5309 deserializer.deserialize_identifier(GeneratedVisitor)
5310 }
5311 }
5312 struct GeneratedVisitor;
5313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5314 type Value = GetVersionByEpochResponse;
5315
5316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5317 formatter.write_str("struct hummock.GetVersionByEpochResponse")
5318 }
5319
5320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
5321 where
5322 V: serde::de::MapAccess<'de>,
5323 {
5324 let mut version__ = None;
5325 while let Some(k) = map_.next_key()? {
5326 match k {
5327 GeneratedField::Version => {
5328 if version__.is_some() {
5329 return Err(serde::de::Error::duplicate_field("version"));
5330 }
5331 version__ = map_.next_value()?;
5332 }
5333 }
5334 }
5335 Ok(GetVersionByEpochResponse {
5336 version: version__,
5337 })
5338 }
5339 }
5340 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
5341 }
5342}
5343impl serde::Serialize for GroupConstruct {
5344 #[allow(deprecated)]
5345 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5346 where
5347 S: serde::Serializer,
5348 {
5349 use serde::ser::SerializeStruct;
5350 let mut len = 0;
5351 if self.group_config.is_some() {
5352 len += 1;
5353 }
5354 if self.parent_group_id != 0 {
5355 len += 1;
5356 }
5357 if !self.table_ids.is_empty() {
5358 len += 1;
5359 }
5360 if self.group_id != 0 {
5361 len += 1;
5362 }
5363 if self.new_sst_start_id != 0 {
5364 len += 1;
5365 }
5366 if self.version != 0 {
5367 len += 1;
5368 }
5369 if self.split_key.is_some() {
5370 len += 1;
5371 }
5372 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
5373 if let Some(v) = self.group_config.as_ref() {
5374 struct_ser.serialize_field("groupConfig", v)?;
5375 }
5376 if self.parent_group_id != 0 {
5377 #[allow(clippy::needless_borrow)]
5378 #[allow(clippy::needless_borrows_for_generic_args)]
5379 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
5380 }
5381 if !self.table_ids.is_empty() {
5382 struct_ser.serialize_field("tableIds", &self.table_ids)?;
5383 }
5384 if self.group_id != 0 {
5385 #[allow(clippy::needless_borrow)]
5386 #[allow(clippy::needless_borrows_for_generic_args)]
5387 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
5388 }
5389 if self.new_sst_start_id != 0 {
5390 #[allow(clippy::needless_borrow)]
5391 #[allow(clippy::needless_borrows_for_generic_args)]
5392 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
5393 }
5394 if self.version != 0 {
5395 let v = CompatibilityVersion::try_from(self.version)
5396 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5397 struct_ser.serialize_field("version", &v)?;
5398 }
5399 if let Some(v) = self.split_key.as_ref() {
5400 #[allow(clippy::needless_borrow)]
5401 #[allow(clippy::needless_borrows_for_generic_args)]
5402 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
5403 }
5404 struct_ser.end()
5405 }
5406}
5407impl<'de> serde::Deserialize<'de> for GroupConstruct {
5408 #[allow(deprecated)]
5409 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5410 where
5411 D: serde::Deserializer<'de>,
5412 {
5413 const FIELDS: &[&str] = &[
5414 "group_config",
5415 "groupConfig",
5416 "parent_group_id",
5417 "parentGroupId",
5418 "table_ids",
5419 "tableIds",
5420 "group_id",
5421 "groupId",
5422 "new_sst_start_id",
5423 "newSstStartId",
5424 "version",
5425 "split_key",
5426 "splitKey",
5427 ];
5428
5429 #[allow(clippy::enum_variant_names)]
5430 enum GeneratedField {
5431 GroupConfig,
5432 ParentGroupId,
5433 TableIds,
5434 GroupId,
5435 NewSstStartId,
5436 Version,
5437 SplitKey,
5438 }
5439 impl<'de> serde::Deserialize<'de> for GeneratedField {
5440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5441 where
5442 D: serde::Deserializer<'de>,
5443 {
5444 struct GeneratedVisitor;
5445
5446 impl serde::de::Visitor<'_> for GeneratedVisitor {
5447 type Value = GeneratedField;
5448
5449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5450 write!(formatter, "expected one of: {:?}", &FIELDS)
5451 }
5452
5453 #[allow(unused_variables)]
5454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5455 where
5456 E: serde::de::Error,
5457 {
5458 match value {
5459 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
5460 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
5461 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
5462 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
5463 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
5464 "version" => Ok(GeneratedField::Version),
5465 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
5466 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5467 }
5468 }
5469 }
5470 deserializer.deserialize_identifier(GeneratedVisitor)
5471 }
5472 }
5473 struct GeneratedVisitor;
5474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5475 type Value = GroupConstruct;
5476
5477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5478 formatter.write_str("struct hummock.GroupConstruct")
5479 }
5480
5481 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
5482 where
5483 V: serde::de::MapAccess<'de>,
5484 {
5485 let mut group_config__ = None;
5486 let mut parent_group_id__ = None;
5487 let mut table_ids__ = None;
5488 let mut group_id__ = None;
5489 let mut new_sst_start_id__ = None;
5490 let mut version__ = None;
5491 let mut split_key__ = None;
5492 while let Some(k) = map_.next_key()? {
5493 match k {
5494 GeneratedField::GroupConfig => {
5495 if group_config__.is_some() {
5496 return Err(serde::de::Error::duplicate_field("groupConfig"));
5497 }
5498 group_config__ = map_.next_value()?;
5499 }
5500 GeneratedField::ParentGroupId => {
5501 if parent_group_id__.is_some() {
5502 return Err(serde::de::Error::duplicate_field("parentGroupId"));
5503 }
5504 parent_group_id__ =
5505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5506 ;
5507 }
5508 GeneratedField::TableIds => {
5509 if table_ids__.is_some() {
5510 return Err(serde::de::Error::duplicate_field("tableIds"));
5511 }
5512 table_ids__ =
5513 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5514 .into_iter().map(|x| x.0).collect())
5515 ;
5516 }
5517 GeneratedField::GroupId => {
5518 if group_id__.is_some() {
5519 return Err(serde::de::Error::duplicate_field("groupId"));
5520 }
5521 group_id__ =
5522 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5523 ;
5524 }
5525 GeneratedField::NewSstStartId => {
5526 if new_sst_start_id__.is_some() {
5527 return Err(serde::de::Error::duplicate_field("newSstStartId"));
5528 }
5529 new_sst_start_id__ =
5530 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5531 ;
5532 }
5533 GeneratedField::Version => {
5534 if version__.is_some() {
5535 return Err(serde::de::Error::duplicate_field("version"));
5536 }
5537 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
5538 }
5539 GeneratedField::SplitKey => {
5540 if split_key__.is_some() {
5541 return Err(serde::de::Error::duplicate_field("splitKey"));
5542 }
5543 split_key__ =
5544 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
5545 ;
5546 }
5547 }
5548 }
5549 Ok(GroupConstruct {
5550 group_config: group_config__,
5551 parent_group_id: parent_group_id__.unwrap_or_default(),
5552 table_ids: table_ids__.unwrap_or_default(),
5553 group_id: group_id__.unwrap_or_default(),
5554 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
5555 version: version__.unwrap_or_default(),
5556 split_key: split_key__,
5557 })
5558 }
5559 }
5560 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
5561 }
5562}
5563impl serde::Serialize for GroupDelta {
5564 #[allow(deprecated)]
5565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5566 where
5567 S: serde::Serializer,
5568 {
5569 use serde::ser::SerializeStruct;
5570 let mut len = 0;
5571 if self.delta_type.is_some() {
5572 len += 1;
5573 }
5574 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
5575 if let Some(v) = self.delta_type.as_ref() {
5576 match v {
5577 group_delta::DeltaType::IntraLevel(v) => {
5578 struct_ser.serialize_field("intraLevel", v)?;
5579 }
5580 group_delta::DeltaType::GroupConstruct(v) => {
5581 struct_ser.serialize_field("groupConstruct", v)?;
5582 }
5583 group_delta::DeltaType::GroupDestroy(v) => {
5584 struct_ser.serialize_field("groupDestroy", v)?;
5585 }
5586 group_delta::DeltaType::GroupMerge(v) => {
5587 struct_ser.serialize_field("groupMerge", v)?;
5588 }
5589 group_delta::DeltaType::NewL0SubLevel(v) => {
5590 struct_ser.serialize_field("newL0SubLevel", v)?;
5591 }
5592 group_delta::DeltaType::TruncateTables(v) => {
5593 struct_ser.serialize_field("truncateTables", v)?;
5594 }
5595 }
5596 }
5597 struct_ser.end()
5598 }
5599}
5600impl<'de> serde::Deserialize<'de> for GroupDelta {
5601 #[allow(deprecated)]
5602 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5603 where
5604 D: serde::Deserializer<'de>,
5605 {
5606 const FIELDS: &[&str] = &[
5607 "intra_level",
5608 "intraLevel",
5609 "group_construct",
5610 "groupConstruct",
5611 "group_destroy",
5612 "groupDestroy",
5613 "group_merge",
5614 "groupMerge",
5615 "new_l0_sub_level",
5616 "newL0SubLevel",
5617 "truncate_tables",
5618 "truncateTables",
5619 ];
5620
5621 #[allow(clippy::enum_variant_names)]
5622 enum GeneratedField {
5623 IntraLevel,
5624 GroupConstruct,
5625 GroupDestroy,
5626 GroupMerge,
5627 NewL0SubLevel,
5628 TruncateTables,
5629 }
5630 impl<'de> serde::Deserialize<'de> for GeneratedField {
5631 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5632 where
5633 D: serde::Deserializer<'de>,
5634 {
5635 struct GeneratedVisitor;
5636
5637 impl serde::de::Visitor<'_> for GeneratedVisitor {
5638 type Value = GeneratedField;
5639
5640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5641 write!(formatter, "expected one of: {:?}", &FIELDS)
5642 }
5643
5644 #[allow(unused_variables)]
5645 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5646 where
5647 E: serde::de::Error,
5648 {
5649 match value {
5650 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5651 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5652 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5653 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5654 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5655 "truncateTables" | "truncate_tables" => Ok(GeneratedField::TruncateTables),
5656 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5657 }
5658 }
5659 }
5660 deserializer.deserialize_identifier(GeneratedVisitor)
5661 }
5662 }
5663 struct GeneratedVisitor;
5664 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5665 type Value = GroupDelta;
5666
5667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5668 formatter.write_str("struct hummock.GroupDelta")
5669 }
5670
5671 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5672 where
5673 V: serde::de::MapAccess<'de>,
5674 {
5675 let mut delta_type__ = None;
5676 while let Some(k) = map_.next_key()? {
5677 match k {
5678 GeneratedField::IntraLevel => {
5679 if delta_type__.is_some() {
5680 return Err(serde::de::Error::duplicate_field("intraLevel"));
5681 }
5682 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5683;
5684 }
5685 GeneratedField::GroupConstruct => {
5686 if delta_type__.is_some() {
5687 return Err(serde::de::Error::duplicate_field("groupConstruct"));
5688 }
5689 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5690;
5691 }
5692 GeneratedField::GroupDestroy => {
5693 if delta_type__.is_some() {
5694 return Err(serde::de::Error::duplicate_field("groupDestroy"));
5695 }
5696 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5697;
5698 }
5699 GeneratedField::GroupMerge => {
5700 if delta_type__.is_some() {
5701 return Err(serde::de::Error::duplicate_field("groupMerge"));
5702 }
5703 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5704;
5705 }
5706 GeneratedField::NewL0SubLevel => {
5707 if delta_type__.is_some() {
5708 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5709 }
5710 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5711;
5712 }
5713 GeneratedField::TruncateTables => {
5714 if delta_type__.is_some() {
5715 return Err(serde::de::Error::duplicate_field("truncateTables"));
5716 }
5717 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::TruncateTables)
5718;
5719 }
5720 }
5721 }
5722 Ok(GroupDelta {
5723 delta_type: delta_type__,
5724 })
5725 }
5726 }
5727 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5728 }
5729}
5730impl serde::Serialize for GroupDestroy {
5731 #[allow(deprecated)]
5732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5733 where
5734 S: serde::Serializer,
5735 {
5736 use serde::ser::SerializeStruct;
5737 let len = 0;
5738 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5739 struct_ser.end()
5740 }
5741}
5742impl<'de> serde::Deserialize<'de> for GroupDestroy {
5743 #[allow(deprecated)]
5744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5745 where
5746 D: serde::Deserializer<'de>,
5747 {
5748 const FIELDS: &[&str] = &[
5749 ];
5750
5751 #[allow(clippy::enum_variant_names)]
5752 enum GeneratedField {
5753 }
5754 impl<'de> serde::Deserialize<'de> for GeneratedField {
5755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5756 where
5757 D: serde::Deserializer<'de>,
5758 {
5759 struct GeneratedVisitor;
5760
5761 impl serde::de::Visitor<'_> for GeneratedVisitor {
5762 type Value = GeneratedField;
5763
5764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5765 write!(formatter, "expected one of: {:?}", &FIELDS)
5766 }
5767
5768 #[allow(unused_variables)]
5769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5770 where
5771 E: serde::de::Error,
5772 {
5773 Err(serde::de::Error::unknown_field(value, FIELDS))
5774 }
5775 }
5776 deserializer.deserialize_identifier(GeneratedVisitor)
5777 }
5778 }
5779 struct GeneratedVisitor;
5780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5781 type Value = GroupDestroy;
5782
5783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5784 formatter.write_str("struct hummock.GroupDestroy")
5785 }
5786
5787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5788 where
5789 V: serde::de::MapAccess<'de>,
5790 {
5791 while map_.next_key::<GeneratedField>()?.is_some() {
5792 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5793 }
5794 Ok(GroupDestroy {
5795 })
5796 }
5797 }
5798 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5799 }
5800}
5801impl serde::Serialize for GroupMerge {
5802 #[allow(deprecated)]
5803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5804 where
5805 S: serde::Serializer,
5806 {
5807 use serde::ser::SerializeStruct;
5808 let mut len = 0;
5809 if self.left_group_id != 0 {
5810 len += 1;
5811 }
5812 if self.right_group_id != 0 {
5813 len += 1;
5814 }
5815 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5816 if self.left_group_id != 0 {
5817 #[allow(clippy::needless_borrow)]
5818 #[allow(clippy::needless_borrows_for_generic_args)]
5819 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5820 }
5821 if self.right_group_id != 0 {
5822 #[allow(clippy::needless_borrow)]
5823 #[allow(clippy::needless_borrows_for_generic_args)]
5824 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5825 }
5826 struct_ser.end()
5827 }
5828}
5829impl<'de> serde::Deserialize<'de> for GroupMerge {
5830 #[allow(deprecated)]
5831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5832 where
5833 D: serde::Deserializer<'de>,
5834 {
5835 const FIELDS: &[&str] = &[
5836 "left_group_id",
5837 "leftGroupId",
5838 "right_group_id",
5839 "rightGroupId",
5840 ];
5841
5842 #[allow(clippy::enum_variant_names)]
5843 enum GeneratedField {
5844 LeftGroupId,
5845 RightGroupId,
5846 }
5847 impl<'de> serde::Deserialize<'de> for GeneratedField {
5848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5849 where
5850 D: serde::Deserializer<'de>,
5851 {
5852 struct GeneratedVisitor;
5853
5854 impl serde::de::Visitor<'_> for GeneratedVisitor {
5855 type Value = GeneratedField;
5856
5857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5858 write!(formatter, "expected one of: {:?}", &FIELDS)
5859 }
5860
5861 #[allow(unused_variables)]
5862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5863 where
5864 E: serde::de::Error,
5865 {
5866 match value {
5867 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5868 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5869 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5870 }
5871 }
5872 }
5873 deserializer.deserialize_identifier(GeneratedVisitor)
5874 }
5875 }
5876 struct GeneratedVisitor;
5877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5878 type Value = GroupMerge;
5879
5880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5881 formatter.write_str("struct hummock.GroupMerge")
5882 }
5883
5884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5885 where
5886 V: serde::de::MapAccess<'de>,
5887 {
5888 let mut left_group_id__ = None;
5889 let mut right_group_id__ = None;
5890 while let Some(k) = map_.next_key()? {
5891 match k {
5892 GeneratedField::LeftGroupId => {
5893 if left_group_id__.is_some() {
5894 return Err(serde::de::Error::duplicate_field("leftGroupId"));
5895 }
5896 left_group_id__ =
5897 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5898 ;
5899 }
5900 GeneratedField::RightGroupId => {
5901 if right_group_id__.is_some() {
5902 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5903 }
5904 right_group_id__ =
5905 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5906 ;
5907 }
5908 }
5909 }
5910 Ok(GroupMerge {
5911 left_group_id: left_group_id__.unwrap_or_default(),
5912 right_group_id: right_group_id__.unwrap_or_default(),
5913 })
5914 }
5915 }
5916 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5917 }
5918}
5919impl serde::Serialize for HnswFlatIndex {
5920 #[allow(deprecated)]
5921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5922 where
5923 S: serde::Serializer,
5924 {
5925 use serde::ser::SerializeStruct;
5926 let mut len = 0;
5927 if self.config.is_some() {
5928 len += 1;
5929 }
5930 if !self.vector_files.is_empty() {
5931 len += 1;
5932 }
5933 if self.next_vector_id != 0 {
5934 len += 1;
5935 }
5936 if self.graph_file.is_some() {
5937 len += 1;
5938 }
5939 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndex", len)?;
5940 if let Some(v) = self.config.as_ref() {
5941 struct_ser.serialize_field("config", v)?;
5942 }
5943 if !self.vector_files.is_empty() {
5944 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
5945 }
5946 if self.next_vector_id != 0 {
5947 #[allow(clippy::needless_borrow)]
5948 #[allow(clippy::needless_borrows_for_generic_args)]
5949 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5950 }
5951 if let Some(v) = self.graph_file.as_ref() {
5952 struct_ser.serialize_field("graphFile", v)?;
5953 }
5954 struct_ser.end()
5955 }
5956}
5957impl<'de> serde::Deserialize<'de> for HnswFlatIndex {
5958 #[allow(deprecated)]
5959 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5960 where
5961 D: serde::Deserializer<'de>,
5962 {
5963 const FIELDS: &[&str] = &[
5964 "config",
5965 "vector_files",
5966 "vectorFiles",
5967 "next_vector_id",
5968 "nextVectorId",
5969 "graph_file",
5970 "graphFile",
5971 ];
5972
5973 #[allow(clippy::enum_variant_names)]
5974 enum GeneratedField {
5975 Config,
5976 VectorFiles,
5977 NextVectorId,
5978 GraphFile,
5979 }
5980 impl<'de> serde::Deserialize<'de> for GeneratedField {
5981 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5982 where
5983 D: serde::Deserializer<'de>,
5984 {
5985 struct GeneratedVisitor;
5986
5987 impl serde::de::Visitor<'_> for GeneratedVisitor {
5988 type Value = GeneratedField;
5989
5990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5991 write!(formatter, "expected one of: {:?}", &FIELDS)
5992 }
5993
5994 #[allow(unused_variables)]
5995 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5996 where
5997 E: serde::de::Error,
5998 {
5999 match value {
6000 "config" => Ok(GeneratedField::Config),
6001 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
6002 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
6003 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
6004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6005 }
6006 }
6007 }
6008 deserializer.deserialize_identifier(GeneratedVisitor)
6009 }
6010 }
6011 struct GeneratedVisitor;
6012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6013 type Value = HnswFlatIndex;
6014
6015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6016 formatter.write_str("struct hummock.HnswFlatIndex")
6017 }
6018
6019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndex, V::Error>
6020 where
6021 V: serde::de::MapAccess<'de>,
6022 {
6023 let mut config__ = None;
6024 let mut vector_files__ = None;
6025 let mut next_vector_id__ = None;
6026 let mut graph_file__ = None;
6027 while let Some(k) = map_.next_key()? {
6028 match k {
6029 GeneratedField::Config => {
6030 if config__.is_some() {
6031 return Err(serde::de::Error::duplicate_field("config"));
6032 }
6033 config__ = map_.next_value()?;
6034 }
6035 GeneratedField::VectorFiles => {
6036 if vector_files__.is_some() {
6037 return Err(serde::de::Error::duplicate_field("vectorFiles"));
6038 }
6039 vector_files__ = Some(map_.next_value()?);
6040 }
6041 GeneratedField::NextVectorId => {
6042 if next_vector_id__.is_some() {
6043 return Err(serde::de::Error::duplicate_field("nextVectorId"));
6044 }
6045 next_vector_id__ =
6046 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6047 ;
6048 }
6049 GeneratedField::GraphFile => {
6050 if graph_file__.is_some() {
6051 return Err(serde::de::Error::duplicate_field("graphFile"));
6052 }
6053 graph_file__ = map_.next_value()?;
6054 }
6055 }
6056 }
6057 Ok(HnswFlatIndex {
6058 config: config__,
6059 vector_files: vector_files__.unwrap_or_default(),
6060 next_vector_id: next_vector_id__.unwrap_or_default(),
6061 graph_file: graph_file__,
6062 })
6063 }
6064 }
6065 deserializer.deserialize_struct("hummock.HnswFlatIndex", FIELDS, GeneratedVisitor)
6066 }
6067}
6068impl serde::Serialize for HnswFlatIndexAdd {
6069 #[allow(deprecated)]
6070 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6071 where
6072 S: serde::Serializer,
6073 {
6074 use serde::ser::SerializeStruct;
6075 let mut len = 0;
6076 if !self.added_vector_files.is_empty() {
6077 len += 1;
6078 }
6079 if self.next_vector_id != 0 {
6080 len += 1;
6081 }
6082 if self.graph_file.is_some() {
6083 len += 1;
6084 }
6085 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndexAdd", len)?;
6086 if !self.added_vector_files.is_empty() {
6087 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
6088 }
6089 if self.next_vector_id != 0 {
6090 #[allow(clippy::needless_borrow)]
6091 #[allow(clippy::needless_borrows_for_generic_args)]
6092 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
6093 }
6094 if let Some(v) = self.graph_file.as_ref() {
6095 struct_ser.serialize_field("graphFile", v)?;
6096 }
6097 struct_ser.end()
6098 }
6099}
6100impl<'de> serde::Deserialize<'de> for HnswFlatIndexAdd {
6101 #[allow(deprecated)]
6102 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6103 where
6104 D: serde::Deserializer<'de>,
6105 {
6106 const FIELDS: &[&str] = &[
6107 "added_vector_files",
6108 "addedVectorFiles",
6109 "next_vector_id",
6110 "nextVectorId",
6111 "graph_file",
6112 "graphFile",
6113 ];
6114
6115 #[allow(clippy::enum_variant_names)]
6116 enum GeneratedField {
6117 AddedVectorFiles,
6118 NextVectorId,
6119 GraphFile,
6120 }
6121 impl<'de> serde::Deserialize<'de> for GeneratedField {
6122 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6123 where
6124 D: serde::Deserializer<'de>,
6125 {
6126 struct GeneratedVisitor;
6127
6128 impl serde::de::Visitor<'_> for GeneratedVisitor {
6129 type Value = GeneratedField;
6130
6131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6132 write!(formatter, "expected one of: {:?}", &FIELDS)
6133 }
6134
6135 #[allow(unused_variables)]
6136 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6137 where
6138 E: serde::de::Error,
6139 {
6140 match value {
6141 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
6142 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
6143 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
6144 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6145 }
6146 }
6147 }
6148 deserializer.deserialize_identifier(GeneratedVisitor)
6149 }
6150 }
6151 struct GeneratedVisitor;
6152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6153 type Value = HnswFlatIndexAdd;
6154
6155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6156 formatter.write_str("struct hummock.HnswFlatIndexAdd")
6157 }
6158
6159 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndexAdd, V::Error>
6160 where
6161 V: serde::de::MapAccess<'de>,
6162 {
6163 let mut added_vector_files__ = None;
6164 let mut next_vector_id__ = None;
6165 let mut graph_file__ = None;
6166 while let Some(k) = map_.next_key()? {
6167 match k {
6168 GeneratedField::AddedVectorFiles => {
6169 if added_vector_files__.is_some() {
6170 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
6171 }
6172 added_vector_files__ = Some(map_.next_value()?);
6173 }
6174 GeneratedField::NextVectorId => {
6175 if next_vector_id__.is_some() {
6176 return Err(serde::de::Error::duplicate_field("nextVectorId"));
6177 }
6178 next_vector_id__ =
6179 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6180 ;
6181 }
6182 GeneratedField::GraphFile => {
6183 if graph_file__.is_some() {
6184 return Err(serde::de::Error::duplicate_field("graphFile"));
6185 }
6186 graph_file__ = map_.next_value()?;
6187 }
6188 }
6189 }
6190 Ok(HnswFlatIndexAdd {
6191 added_vector_files: added_vector_files__.unwrap_or_default(),
6192 next_vector_id: next_vector_id__.unwrap_or_default(),
6193 graph_file: graph_file__,
6194 })
6195 }
6196 }
6197 deserializer.deserialize_struct("hummock.HnswFlatIndexAdd", FIELDS, GeneratedVisitor)
6198 }
6199}
6200impl serde::Serialize for HnswGraph {
6201 #[allow(deprecated)]
6202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6203 where
6204 S: serde::Serializer,
6205 {
6206 use serde::ser::SerializeStruct;
6207 let mut len = 0;
6208 if !self.nodes.is_empty() {
6209 len += 1;
6210 }
6211 if self.entrypoint_id != 0 {
6212 len += 1;
6213 }
6214 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph", len)?;
6215 if !self.nodes.is_empty() {
6216 struct_ser.serialize_field("nodes", &self.nodes)?;
6217 }
6218 if self.entrypoint_id != 0 {
6219 #[allow(clippy::needless_borrow)]
6220 #[allow(clippy::needless_borrows_for_generic_args)]
6221 struct_ser.serialize_field("entrypointId", ToString::to_string(&self.entrypoint_id).as_str())?;
6222 }
6223 struct_ser.end()
6224 }
6225}
6226impl<'de> serde::Deserialize<'de> for HnswGraph {
6227 #[allow(deprecated)]
6228 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6229 where
6230 D: serde::Deserializer<'de>,
6231 {
6232 const FIELDS: &[&str] = &[
6233 "nodes",
6234 "entrypoint_id",
6235 "entrypointId",
6236 ];
6237
6238 #[allow(clippy::enum_variant_names)]
6239 enum GeneratedField {
6240 Nodes,
6241 EntrypointId,
6242 }
6243 impl<'de> serde::Deserialize<'de> for GeneratedField {
6244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6245 where
6246 D: serde::Deserializer<'de>,
6247 {
6248 struct GeneratedVisitor;
6249
6250 impl serde::de::Visitor<'_> for GeneratedVisitor {
6251 type Value = GeneratedField;
6252
6253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6254 write!(formatter, "expected one of: {:?}", &FIELDS)
6255 }
6256
6257 #[allow(unused_variables)]
6258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6259 where
6260 E: serde::de::Error,
6261 {
6262 match value {
6263 "nodes" => Ok(GeneratedField::Nodes),
6264 "entrypointId" | "entrypoint_id" => Ok(GeneratedField::EntrypointId),
6265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6266 }
6267 }
6268 }
6269 deserializer.deserialize_identifier(GeneratedVisitor)
6270 }
6271 }
6272 struct GeneratedVisitor;
6273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6274 type Value = HnswGraph;
6275
6276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6277 formatter.write_str("struct hummock.HnswGraph")
6278 }
6279
6280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraph, V::Error>
6281 where
6282 V: serde::de::MapAccess<'de>,
6283 {
6284 let mut nodes__ = None;
6285 let mut entrypoint_id__ = None;
6286 while let Some(k) = map_.next_key()? {
6287 match k {
6288 GeneratedField::Nodes => {
6289 if nodes__.is_some() {
6290 return Err(serde::de::Error::duplicate_field("nodes"));
6291 }
6292 nodes__ = Some(map_.next_value()?);
6293 }
6294 GeneratedField::EntrypointId => {
6295 if entrypoint_id__.is_some() {
6296 return Err(serde::de::Error::duplicate_field("entrypointId"));
6297 }
6298 entrypoint_id__ =
6299 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6300 ;
6301 }
6302 }
6303 }
6304 Ok(HnswGraph {
6305 nodes: nodes__.unwrap_or_default(),
6306 entrypoint_id: entrypoint_id__.unwrap_or_default(),
6307 })
6308 }
6309 }
6310 deserializer.deserialize_struct("hummock.HnswGraph", FIELDS, GeneratedVisitor)
6311 }
6312}
6313impl serde::Serialize for hnsw_graph::HnswLevel {
6314 #[allow(deprecated)]
6315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6316 where
6317 S: serde::Serializer,
6318 {
6319 use serde::ser::SerializeStruct;
6320 let mut len = 0;
6321 if !self.neighbors.is_empty() {
6322 len += 1;
6323 }
6324 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswLevel", len)?;
6325 if !self.neighbors.is_empty() {
6326 struct_ser.serialize_field("neighbors", &self.neighbors)?;
6327 }
6328 struct_ser.end()
6329 }
6330}
6331impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswLevel {
6332 #[allow(deprecated)]
6333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6334 where
6335 D: serde::Deserializer<'de>,
6336 {
6337 const FIELDS: &[&str] = &[
6338 "neighbors",
6339 ];
6340
6341 #[allow(clippy::enum_variant_names)]
6342 enum GeneratedField {
6343 Neighbors,
6344 }
6345 impl<'de> serde::Deserialize<'de> for GeneratedField {
6346 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6347 where
6348 D: serde::Deserializer<'de>,
6349 {
6350 struct GeneratedVisitor;
6351
6352 impl serde::de::Visitor<'_> for GeneratedVisitor {
6353 type Value = GeneratedField;
6354
6355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6356 write!(formatter, "expected one of: {:?}", &FIELDS)
6357 }
6358
6359 #[allow(unused_variables)]
6360 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6361 where
6362 E: serde::de::Error,
6363 {
6364 match value {
6365 "neighbors" => Ok(GeneratedField::Neighbors),
6366 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6367 }
6368 }
6369 }
6370 deserializer.deserialize_identifier(GeneratedVisitor)
6371 }
6372 }
6373 struct GeneratedVisitor;
6374 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6375 type Value = hnsw_graph::HnswLevel;
6376
6377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6378 formatter.write_str("struct hummock.HnswGraph.HnswLevel")
6379 }
6380
6381 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswLevel, V::Error>
6382 where
6383 V: serde::de::MapAccess<'de>,
6384 {
6385 let mut neighbors__ = None;
6386 while let Some(k) = map_.next_key()? {
6387 match k {
6388 GeneratedField::Neighbors => {
6389 if neighbors__.is_some() {
6390 return Err(serde::de::Error::duplicate_field("neighbors"));
6391 }
6392 neighbors__ = Some(map_.next_value()?);
6393 }
6394 }
6395 }
6396 Ok(hnsw_graph::HnswLevel {
6397 neighbors: neighbors__.unwrap_or_default(),
6398 })
6399 }
6400 }
6401 deserializer.deserialize_struct("hummock.HnswGraph.HnswLevel", FIELDS, GeneratedVisitor)
6402 }
6403}
6404impl serde::Serialize for hnsw_graph::HnswNeighbor {
6405 #[allow(deprecated)]
6406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6407 where
6408 S: serde::Serializer,
6409 {
6410 use serde::ser::SerializeStruct;
6411 let mut len = 0;
6412 if self.vector_id != 0 {
6413 len += 1;
6414 }
6415 if self.distance != 0. {
6416 len += 1;
6417 }
6418 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNeighbor", len)?;
6419 if self.vector_id != 0 {
6420 #[allow(clippy::needless_borrow)]
6421 #[allow(clippy::needless_borrows_for_generic_args)]
6422 struct_ser.serialize_field("vectorId", ToString::to_string(&self.vector_id).as_str())?;
6423 }
6424 if self.distance != 0. {
6425 struct_ser.serialize_field("distance", &self.distance)?;
6426 }
6427 struct_ser.end()
6428 }
6429}
6430impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNeighbor {
6431 #[allow(deprecated)]
6432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6433 where
6434 D: serde::Deserializer<'de>,
6435 {
6436 const FIELDS: &[&str] = &[
6437 "vector_id",
6438 "vectorId",
6439 "distance",
6440 ];
6441
6442 #[allow(clippy::enum_variant_names)]
6443 enum GeneratedField {
6444 VectorId,
6445 Distance,
6446 }
6447 impl<'de> serde::Deserialize<'de> for GeneratedField {
6448 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6449 where
6450 D: serde::Deserializer<'de>,
6451 {
6452 struct GeneratedVisitor;
6453
6454 impl serde::de::Visitor<'_> for GeneratedVisitor {
6455 type Value = GeneratedField;
6456
6457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6458 write!(formatter, "expected one of: {:?}", &FIELDS)
6459 }
6460
6461 #[allow(unused_variables)]
6462 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6463 where
6464 E: serde::de::Error,
6465 {
6466 match value {
6467 "vectorId" | "vector_id" => Ok(GeneratedField::VectorId),
6468 "distance" => Ok(GeneratedField::Distance),
6469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6470 }
6471 }
6472 }
6473 deserializer.deserialize_identifier(GeneratedVisitor)
6474 }
6475 }
6476 struct GeneratedVisitor;
6477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6478 type Value = hnsw_graph::HnswNeighbor;
6479
6480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6481 formatter.write_str("struct hummock.HnswGraph.HnswNeighbor")
6482 }
6483
6484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNeighbor, V::Error>
6485 where
6486 V: serde::de::MapAccess<'de>,
6487 {
6488 let mut vector_id__ = None;
6489 let mut distance__ = None;
6490 while let Some(k) = map_.next_key()? {
6491 match k {
6492 GeneratedField::VectorId => {
6493 if vector_id__.is_some() {
6494 return Err(serde::de::Error::duplicate_field("vectorId"));
6495 }
6496 vector_id__ =
6497 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6498 ;
6499 }
6500 GeneratedField::Distance => {
6501 if distance__.is_some() {
6502 return Err(serde::de::Error::duplicate_field("distance"));
6503 }
6504 distance__ =
6505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6506 ;
6507 }
6508 }
6509 }
6510 Ok(hnsw_graph::HnswNeighbor {
6511 vector_id: vector_id__.unwrap_or_default(),
6512 distance: distance__.unwrap_or_default(),
6513 })
6514 }
6515 }
6516 deserializer.deserialize_struct("hummock.HnswGraph.HnswNeighbor", FIELDS, GeneratedVisitor)
6517 }
6518}
6519impl serde::Serialize for hnsw_graph::HnswNode {
6520 #[allow(deprecated)]
6521 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6522 where
6523 S: serde::Serializer,
6524 {
6525 use serde::ser::SerializeStruct;
6526 let mut len = 0;
6527 if !self.levels.is_empty() {
6528 len += 1;
6529 }
6530 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNode", len)?;
6531 if !self.levels.is_empty() {
6532 struct_ser.serialize_field("levels", &self.levels)?;
6533 }
6534 struct_ser.end()
6535 }
6536}
6537impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNode {
6538 #[allow(deprecated)]
6539 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6540 where
6541 D: serde::Deserializer<'de>,
6542 {
6543 const FIELDS: &[&str] = &[
6544 "levels",
6545 ];
6546
6547 #[allow(clippy::enum_variant_names)]
6548 enum GeneratedField {
6549 Levels,
6550 }
6551 impl<'de> serde::Deserialize<'de> for GeneratedField {
6552 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6553 where
6554 D: serde::Deserializer<'de>,
6555 {
6556 struct GeneratedVisitor;
6557
6558 impl serde::de::Visitor<'_> for GeneratedVisitor {
6559 type Value = GeneratedField;
6560
6561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6562 write!(formatter, "expected one of: {:?}", &FIELDS)
6563 }
6564
6565 #[allow(unused_variables)]
6566 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6567 where
6568 E: serde::de::Error,
6569 {
6570 match value {
6571 "levels" => Ok(GeneratedField::Levels),
6572 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6573 }
6574 }
6575 }
6576 deserializer.deserialize_identifier(GeneratedVisitor)
6577 }
6578 }
6579 struct GeneratedVisitor;
6580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6581 type Value = hnsw_graph::HnswNode;
6582
6583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6584 formatter.write_str("struct hummock.HnswGraph.HnswNode")
6585 }
6586
6587 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNode, V::Error>
6588 where
6589 V: serde::de::MapAccess<'de>,
6590 {
6591 let mut levels__ = None;
6592 while let Some(k) = map_.next_key()? {
6593 match k {
6594 GeneratedField::Levels => {
6595 if levels__.is_some() {
6596 return Err(serde::de::Error::duplicate_field("levels"));
6597 }
6598 levels__ = Some(map_.next_value()?);
6599 }
6600 }
6601 }
6602 Ok(hnsw_graph::HnswNode {
6603 levels: levels__.unwrap_or_default(),
6604 })
6605 }
6606 }
6607 deserializer.deserialize_struct("hummock.HnswGraph.HnswNode", FIELDS, GeneratedVisitor)
6608 }
6609}
6610impl serde::Serialize for HnswGraphFileInfo {
6611 #[allow(deprecated)]
6612 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6613 where
6614 S: serde::Serializer,
6615 {
6616 use serde::ser::SerializeStruct;
6617 let mut len = 0;
6618 if self.object_id != 0 {
6619 len += 1;
6620 }
6621 if self.file_size != 0 {
6622 len += 1;
6623 }
6624 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraphFileInfo", len)?;
6625 if self.object_id != 0 {
6626 #[allow(clippy::needless_borrow)]
6627 #[allow(clippy::needless_borrows_for_generic_args)]
6628 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
6629 }
6630 if self.file_size != 0 {
6631 #[allow(clippy::needless_borrow)]
6632 #[allow(clippy::needless_borrows_for_generic_args)]
6633 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
6634 }
6635 struct_ser.end()
6636 }
6637}
6638impl<'de> serde::Deserialize<'de> for HnswGraphFileInfo {
6639 #[allow(deprecated)]
6640 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6641 where
6642 D: serde::Deserializer<'de>,
6643 {
6644 const FIELDS: &[&str] = &[
6645 "object_id",
6646 "objectId",
6647 "file_size",
6648 "fileSize",
6649 ];
6650
6651 #[allow(clippy::enum_variant_names)]
6652 enum GeneratedField {
6653 ObjectId,
6654 FileSize,
6655 }
6656 impl<'de> serde::Deserialize<'de> for GeneratedField {
6657 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6658 where
6659 D: serde::Deserializer<'de>,
6660 {
6661 struct GeneratedVisitor;
6662
6663 impl serde::de::Visitor<'_> for GeneratedVisitor {
6664 type Value = GeneratedField;
6665
6666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6667 write!(formatter, "expected one of: {:?}", &FIELDS)
6668 }
6669
6670 #[allow(unused_variables)]
6671 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6672 where
6673 E: serde::de::Error,
6674 {
6675 match value {
6676 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
6677 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
6678 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6679 }
6680 }
6681 }
6682 deserializer.deserialize_identifier(GeneratedVisitor)
6683 }
6684 }
6685 struct GeneratedVisitor;
6686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6687 type Value = HnswGraphFileInfo;
6688
6689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6690 formatter.write_str("struct hummock.HnswGraphFileInfo")
6691 }
6692
6693 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraphFileInfo, V::Error>
6694 where
6695 V: serde::de::MapAccess<'de>,
6696 {
6697 let mut object_id__ = None;
6698 let mut file_size__ = None;
6699 while let Some(k) = map_.next_key()? {
6700 match k {
6701 GeneratedField::ObjectId => {
6702 if object_id__.is_some() {
6703 return Err(serde::de::Error::duplicate_field("objectId"));
6704 }
6705 object_id__ =
6706 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6707 ;
6708 }
6709 GeneratedField::FileSize => {
6710 if file_size__.is_some() {
6711 return Err(serde::de::Error::duplicate_field("fileSize"));
6712 }
6713 file_size__ =
6714 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6715 ;
6716 }
6717 }
6718 }
6719 Ok(HnswGraphFileInfo {
6720 object_id: object_id__.unwrap_or_default(),
6721 file_size: file_size__.unwrap_or_default(),
6722 })
6723 }
6724 }
6725 deserializer.deserialize_struct("hummock.HnswGraphFileInfo", FIELDS, GeneratedVisitor)
6726 }
6727}
6728impl serde::Serialize for HummockPinnedSnapshot {
6729 #[allow(deprecated)]
6730 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6731 where
6732 S: serde::Serializer,
6733 {
6734 use serde::ser::SerializeStruct;
6735 let mut len = 0;
6736 if self.context_id != 0 {
6737 len += 1;
6738 }
6739 if self.minimal_pinned_snapshot != 0 {
6740 len += 1;
6741 }
6742 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
6743 if self.context_id != 0 {
6744 struct_ser.serialize_field("contextId", &self.context_id)?;
6745 }
6746 if self.minimal_pinned_snapshot != 0 {
6747 #[allow(clippy::needless_borrow)]
6748 #[allow(clippy::needless_borrows_for_generic_args)]
6749 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
6750 }
6751 struct_ser.end()
6752 }
6753}
6754impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
6755 #[allow(deprecated)]
6756 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6757 where
6758 D: serde::Deserializer<'de>,
6759 {
6760 const FIELDS: &[&str] = &[
6761 "context_id",
6762 "contextId",
6763 "minimal_pinned_snapshot",
6764 "minimalPinnedSnapshot",
6765 ];
6766
6767 #[allow(clippy::enum_variant_names)]
6768 enum GeneratedField {
6769 ContextId,
6770 MinimalPinnedSnapshot,
6771 }
6772 impl<'de> serde::Deserialize<'de> for GeneratedField {
6773 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6774 where
6775 D: serde::Deserializer<'de>,
6776 {
6777 struct GeneratedVisitor;
6778
6779 impl serde::de::Visitor<'_> for GeneratedVisitor {
6780 type Value = GeneratedField;
6781
6782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6783 write!(formatter, "expected one of: {:?}", &FIELDS)
6784 }
6785
6786 #[allow(unused_variables)]
6787 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6788 where
6789 E: serde::de::Error,
6790 {
6791 match value {
6792 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6793 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
6794 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6795 }
6796 }
6797 }
6798 deserializer.deserialize_identifier(GeneratedVisitor)
6799 }
6800 }
6801 struct GeneratedVisitor;
6802 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6803 type Value = HummockPinnedSnapshot;
6804
6805 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6806 formatter.write_str("struct hummock.HummockPinnedSnapshot")
6807 }
6808
6809 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
6810 where
6811 V: serde::de::MapAccess<'de>,
6812 {
6813 let mut context_id__ = None;
6814 let mut minimal_pinned_snapshot__ = None;
6815 while let Some(k) = map_.next_key()? {
6816 match k {
6817 GeneratedField::ContextId => {
6818 if context_id__.is_some() {
6819 return Err(serde::de::Error::duplicate_field("contextId"));
6820 }
6821 context_id__ =
6822 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6823 ;
6824 }
6825 GeneratedField::MinimalPinnedSnapshot => {
6826 if minimal_pinned_snapshot__.is_some() {
6827 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
6828 }
6829 minimal_pinned_snapshot__ =
6830 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6831 ;
6832 }
6833 }
6834 }
6835 Ok(HummockPinnedSnapshot {
6836 context_id: context_id__.unwrap_or_default(),
6837 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
6838 })
6839 }
6840 }
6841 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
6842 }
6843}
6844impl serde::Serialize for HummockPinnedVersion {
6845 #[allow(deprecated)]
6846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6847 where
6848 S: serde::Serializer,
6849 {
6850 use serde::ser::SerializeStruct;
6851 let mut len = 0;
6852 if self.context_id != 0 {
6853 len += 1;
6854 }
6855 if self.min_pinned_id != 0 {
6856 len += 1;
6857 }
6858 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
6859 if self.context_id != 0 {
6860 struct_ser.serialize_field("contextId", &self.context_id)?;
6861 }
6862 if self.min_pinned_id != 0 {
6863 #[allow(clippy::needless_borrow)]
6864 #[allow(clippy::needless_borrows_for_generic_args)]
6865 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
6866 }
6867 struct_ser.end()
6868 }
6869}
6870impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
6871 #[allow(deprecated)]
6872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6873 where
6874 D: serde::Deserializer<'de>,
6875 {
6876 const FIELDS: &[&str] = &[
6877 "context_id",
6878 "contextId",
6879 "min_pinned_id",
6880 "minPinnedId",
6881 ];
6882
6883 #[allow(clippy::enum_variant_names)]
6884 enum GeneratedField {
6885 ContextId,
6886 MinPinnedId,
6887 }
6888 impl<'de> serde::Deserialize<'de> for GeneratedField {
6889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6890 where
6891 D: serde::Deserializer<'de>,
6892 {
6893 struct GeneratedVisitor;
6894
6895 impl serde::de::Visitor<'_> for GeneratedVisitor {
6896 type Value = GeneratedField;
6897
6898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6899 write!(formatter, "expected one of: {:?}", &FIELDS)
6900 }
6901
6902 #[allow(unused_variables)]
6903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6904 where
6905 E: serde::de::Error,
6906 {
6907 match value {
6908 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6909 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
6910 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6911 }
6912 }
6913 }
6914 deserializer.deserialize_identifier(GeneratedVisitor)
6915 }
6916 }
6917 struct GeneratedVisitor;
6918 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6919 type Value = HummockPinnedVersion;
6920
6921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6922 formatter.write_str("struct hummock.HummockPinnedVersion")
6923 }
6924
6925 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
6926 where
6927 V: serde::de::MapAccess<'de>,
6928 {
6929 let mut context_id__ = None;
6930 let mut min_pinned_id__ = None;
6931 while let Some(k) = map_.next_key()? {
6932 match k {
6933 GeneratedField::ContextId => {
6934 if context_id__.is_some() {
6935 return Err(serde::de::Error::duplicate_field("contextId"));
6936 }
6937 context_id__ =
6938 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6939 ;
6940 }
6941 GeneratedField::MinPinnedId => {
6942 if min_pinned_id__.is_some() {
6943 return Err(serde::de::Error::duplicate_field("minPinnedId"));
6944 }
6945 min_pinned_id__ =
6946 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6947 ;
6948 }
6949 }
6950 }
6951 Ok(HummockPinnedVersion {
6952 context_id: context_id__.unwrap_or_default(),
6953 min_pinned_id: min_pinned_id__.unwrap_or_default(),
6954 })
6955 }
6956 }
6957 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
6958 }
6959}
6960impl serde::Serialize for HummockVersion {
6961 #[allow(deprecated)]
6962 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6963 where
6964 S: serde::Serializer,
6965 {
6966 use serde::ser::SerializeStruct;
6967 let mut len = 0;
6968 if self.id != 0 {
6969 len += 1;
6970 }
6971 if !self.levels.is_empty() {
6972 len += 1;
6973 }
6974 if self.max_committed_epoch != 0 {
6975 len += 1;
6976 }
6977 if !self.table_watermarks.is_empty() {
6978 len += 1;
6979 }
6980 if !self.table_change_logs.is_empty() {
6981 len += 1;
6982 }
6983 if !self.state_table_info.is_empty() {
6984 len += 1;
6985 }
6986 if !self.vector_indexes.is_empty() {
6987 len += 1;
6988 }
6989 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
6990 if self.id != 0 {
6991 #[allow(clippy::needless_borrow)]
6992 #[allow(clippy::needless_borrows_for_generic_args)]
6993 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6994 }
6995 if !self.levels.is_empty() {
6996 struct_ser.serialize_field("levels", &self.levels)?;
6997 }
6998 if self.max_committed_epoch != 0 {
6999 #[allow(clippy::needless_borrow)]
7000 #[allow(clippy::needless_borrows_for_generic_args)]
7001 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
7002 }
7003 if !self.table_watermarks.is_empty() {
7004 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
7005 }
7006 if !self.table_change_logs.is_empty() {
7007 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
7008 }
7009 if !self.state_table_info.is_empty() {
7010 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
7011 }
7012 if !self.vector_indexes.is_empty() {
7013 struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
7014 }
7015 struct_ser.end()
7016 }
7017}
7018impl<'de> serde::Deserialize<'de> for HummockVersion {
7019 #[allow(deprecated)]
7020 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7021 where
7022 D: serde::Deserializer<'de>,
7023 {
7024 const FIELDS: &[&str] = &[
7025 "id",
7026 "levels",
7027 "max_committed_epoch",
7028 "maxCommittedEpoch",
7029 "table_watermarks",
7030 "tableWatermarks",
7031 "table_change_logs",
7032 "tableChangeLogs",
7033 "state_table_info",
7034 "stateTableInfo",
7035 "vector_indexes",
7036 "vectorIndexes",
7037 ];
7038
7039 #[allow(clippy::enum_variant_names)]
7040 enum GeneratedField {
7041 Id,
7042 Levels,
7043 MaxCommittedEpoch,
7044 TableWatermarks,
7045 TableChangeLogs,
7046 StateTableInfo,
7047 VectorIndexes,
7048 }
7049 impl<'de> serde::Deserialize<'de> for GeneratedField {
7050 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7051 where
7052 D: serde::Deserializer<'de>,
7053 {
7054 struct GeneratedVisitor;
7055
7056 impl serde::de::Visitor<'_> for GeneratedVisitor {
7057 type Value = GeneratedField;
7058
7059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7060 write!(formatter, "expected one of: {:?}", &FIELDS)
7061 }
7062
7063 #[allow(unused_variables)]
7064 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7065 where
7066 E: serde::de::Error,
7067 {
7068 match value {
7069 "id" => Ok(GeneratedField::Id),
7070 "levels" => Ok(GeneratedField::Levels),
7071 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
7072 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
7073 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
7074 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
7075 "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
7076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7077 }
7078 }
7079 }
7080 deserializer.deserialize_identifier(GeneratedVisitor)
7081 }
7082 }
7083 struct GeneratedVisitor;
7084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7085 type Value = HummockVersion;
7086
7087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7088 formatter.write_str("struct hummock.HummockVersion")
7089 }
7090
7091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
7092 where
7093 V: serde::de::MapAccess<'de>,
7094 {
7095 let mut id__ = None;
7096 let mut levels__ = None;
7097 let mut max_committed_epoch__ = None;
7098 let mut table_watermarks__ = None;
7099 let mut table_change_logs__ = None;
7100 let mut state_table_info__ = None;
7101 let mut vector_indexes__ = None;
7102 while let Some(k) = map_.next_key()? {
7103 match k {
7104 GeneratedField::Id => {
7105 if id__.is_some() {
7106 return Err(serde::de::Error::duplicate_field("id"));
7107 }
7108 id__ =
7109 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7110 ;
7111 }
7112 GeneratedField::Levels => {
7113 if levels__.is_some() {
7114 return Err(serde::de::Error::duplicate_field("levels"));
7115 }
7116 levels__ = Some(
7117 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7118 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7119 );
7120 }
7121 GeneratedField::MaxCommittedEpoch => {
7122 if max_committed_epoch__.is_some() {
7123 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
7124 }
7125 max_committed_epoch__ =
7126 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7127 ;
7128 }
7129 GeneratedField::TableWatermarks => {
7130 if table_watermarks__.is_some() {
7131 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
7132 }
7133 table_watermarks__ = Some(
7134 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7135 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7136 );
7137 }
7138 GeneratedField::TableChangeLogs => {
7139 if table_change_logs__.is_some() {
7140 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
7141 }
7142 table_change_logs__ = Some(
7143 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7144 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7145 );
7146 }
7147 GeneratedField::StateTableInfo => {
7148 if state_table_info__.is_some() {
7149 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
7150 }
7151 state_table_info__ = Some(
7152 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7153 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7154 );
7155 }
7156 GeneratedField::VectorIndexes => {
7157 if vector_indexes__.is_some() {
7158 return Err(serde::de::Error::duplicate_field("vectorIndexes"));
7159 }
7160 vector_indexes__ = Some(
7161 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7162 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7163 );
7164 }
7165 }
7166 }
7167 Ok(HummockVersion {
7168 id: id__.unwrap_or_default(),
7169 levels: levels__.unwrap_or_default(),
7170 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
7171 table_watermarks: table_watermarks__.unwrap_or_default(),
7172 table_change_logs: table_change_logs__.unwrap_or_default(),
7173 state_table_info: state_table_info__.unwrap_or_default(),
7174 vector_indexes: vector_indexes__.unwrap_or_default(),
7175 })
7176 }
7177 }
7178 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
7179 }
7180}
7181impl serde::Serialize for hummock_version::Levels {
7182 #[allow(deprecated)]
7183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7184 where
7185 S: serde::Serializer,
7186 {
7187 use serde::ser::SerializeStruct;
7188 let mut len = 0;
7189 if !self.levels.is_empty() {
7190 len += 1;
7191 }
7192 if self.l0.is_some() {
7193 len += 1;
7194 }
7195 if self.group_id != 0 {
7196 len += 1;
7197 }
7198 if self.parent_group_id != 0 {
7199 len += 1;
7200 }
7201 if !self.member_table_ids.is_empty() {
7202 len += 1;
7203 }
7204 if self.compaction_group_version_id != 0 {
7205 len += 1;
7206 }
7207 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
7208 if !self.levels.is_empty() {
7209 struct_ser.serialize_field("levels", &self.levels)?;
7210 }
7211 if let Some(v) = self.l0.as_ref() {
7212 struct_ser.serialize_field("l0", v)?;
7213 }
7214 if self.group_id != 0 {
7215 #[allow(clippy::needless_borrow)]
7216 #[allow(clippy::needless_borrows_for_generic_args)]
7217 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
7218 }
7219 if self.parent_group_id != 0 {
7220 #[allow(clippy::needless_borrow)]
7221 #[allow(clippy::needless_borrows_for_generic_args)]
7222 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
7223 }
7224 if !self.member_table_ids.is_empty() {
7225 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
7226 }
7227 if self.compaction_group_version_id != 0 {
7228 #[allow(clippy::needless_borrow)]
7229 #[allow(clippy::needless_borrows_for_generic_args)]
7230 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
7231 }
7232 struct_ser.end()
7233 }
7234}
7235impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
7236 #[allow(deprecated)]
7237 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7238 where
7239 D: serde::Deserializer<'de>,
7240 {
7241 const FIELDS: &[&str] = &[
7242 "levels",
7243 "l0",
7244 "group_id",
7245 "groupId",
7246 "parent_group_id",
7247 "parentGroupId",
7248 "member_table_ids",
7249 "memberTableIds",
7250 "compaction_group_version_id",
7251 "compactionGroupVersionId",
7252 ];
7253
7254 #[allow(clippy::enum_variant_names)]
7255 enum GeneratedField {
7256 Levels,
7257 L0,
7258 GroupId,
7259 ParentGroupId,
7260 MemberTableIds,
7261 CompactionGroupVersionId,
7262 }
7263 impl<'de> serde::Deserialize<'de> for GeneratedField {
7264 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7265 where
7266 D: serde::Deserializer<'de>,
7267 {
7268 struct GeneratedVisitor;
7269
7270 impl serde::de::Visitor<'_> for GeneratedVisitor {
7271 type Value = GeneratedField;
7272
7273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7274 write!(formatter, "expected one of: {:?}", &FIELDS)
7275 }
7276
7277 #[allow(unused_variables)]
7278 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7279 where
7280 E: serde::de::Error,
7281 {
7282 match value {
7283 "levels" => Ok(GeneratedField::Levels),
7284 "l0" => Ok(GeneratedField::L0),
7285 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
7286 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
7287 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
7288 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
7289 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7290 }
7291 }
7292 }
7293 deserializer.deserialize_identifier(GeneratedVisitor)
7294 }
7295 }
7296 struct GeneratedVisitor;
7297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7298 type Value = hummock_version::Levels;
7299
7300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7301 formatter.write_str("struct hummock.HummockVersion.Levels")
7302 }
7303
7304 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
7305 where
7306 V: serde::de::MapAccess<'de>,
7307 {
7308 let mut levels__ = None;
7309 let mut l0__ = None;
7310 let mut group_id__ = None;
7311 let mut parent_group_id__ = None;
7312 let mut member_table_ids__ = None;
7313 let mut compaction_group_version_id__ = None;
7314 while let Some(k) = map_.next_key()? {
7315 match k {
7316 GeneratedField::Levels => {
7317 if levels__.is_some() {
7318 return Err(serde::de::Error::duplicate_field("levels"));
7319 }
7320 levels__ = Some(map_.next_value()?);
7321 }
7322 GeneratedField::L0 => {
7323 if l0__.is_some() {
7324 return Err(serde::de::Error::duplicate_field("l0"));
7325 }
7326 l0__ = map_.next_value()?;
7327 }
7328 GeneratedField::GroupId => {
7329 if group_id__.is_some() {
7330 return Err(serde::de::Error::duplicate_field("groupId"));
7331 }
7332 group_id__ =
7333 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7334 ;
7335 }
7336 GeneratedField::ParentGroupId => {
7337 if parent_group_id__.is_some() {
7338 return Err(serde::de::Error::duplicate_field("parentGroupId"));
7339 }
7340 parent_group_id__ =
7341 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7342 ;
7343 }
7344 GeneratedField::MemberTableIds => {
7345 if member_table_ids__.is_some() {
7346 return Err(serde::de::Error::duplicate_field("memberTableIds"));
7347 }
7348 member_table_ids__ =
7349 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7350 .into_iter().map(|x| x.0).collect())
7351 ;
7352 }
7353 GeneratedField::CompactionGroupVersionId => {
7354 if compaction_group_version_id__.is_some() {
7355 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
7356 }
7357 compaction_group_version_id__ =
7358 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7359 ;
7360 }
7361 }
7362 }
7363 Ok(hummock_version::Levels {
7364 levels: levels__.unwrap_or_default(),
7365 l0: l0__,
7366 group_id: group_id__.unwrap_or_default(),
7367 parent_group_id: parent_group_id__.unwrap_or_default(),
7368 member_table_ids: member_table_ids__.unwrap_or_default(),
7369 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
7370 })
7371 }
7372 }
7373 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
7374 }
7375}
7376impl serde::Serialize for HummockVersionArchive {
7377 #[allow(deprecated)]
7378 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7379 where
7380 S: serde::Serializer,
7381 {
7382 use serde::ser::SerializeStruct;
7383 let mut len = 0;
7384 if self.version.is_some() {
7385 len += 1;
7386 }
7387 if !self.version_deltas.is_empty() {
7388 len += 1;
7389 }
7390 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
7391 if let Some(v) = self.version.as_ref() {
7392 struct_ser.serialize_field("version", v)?;
7393 }
7394 if !self.version_deltas.is_empty() {
7395 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
7396 }
7397 struct_ser.end()
7398 }
7399}
7400impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
7401 #[allow(deprecated)]
7402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7403 where
7404 D: serde::Deserializer<'de>,
7405 {
7406 const FIELDS: &[&str] = &[
7407 "version",
7408 "version_deltas",
7409 "versionDeltas",
7410 ];
7411
7412 #[allow(clippy::enum_variant_names)]
7413 enum GeneratedField {
7414 Version,
7415 VersionDeltas,
7416 }
7417 impl<'de> serde::Deserialize<'de> for GeneratedField {
7418 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7419 where
7420 D: serde::Deserializer<'de>,
7421 {
7422 struct GeneratedVisitor;
7423
7424 impl serde::de::Visitor<'_> for GeneratedVisitor {
7425 type Value = GeneratedField;
7426
7427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7428 write!(formatter, "expected one of: {:?}", &FIELDS)
7429 }
7430
7431 #[allow(unused_variables)]
7432 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7433 where
7434 E: serde::de::Error,
7435 {
7436 match value {
7437 "version" => Ok(GeneratedField::Version),
7438 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
7439 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7440 }
7441 }
7442 }
7443 deserializer.deserialize_identifier(GeneratedVisitor)
7444 }
7445 }
7446 struct GeneratedVisitor;
7447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7448 type Value = HummockVersionArchive;
7449
7450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7451 formatter.write_str("struct hummock.HummockVersionArchive")
7452 }
7453
7454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
7455 where
7456 V: serde::de::MapAccess<'de>,
7457 {
7458 let mut version__ = None;
7459 let mut version_deltas__ = None;
7460 while let Some(k) = map_.next_key()? {
7461 match k {
7462 GeneratedField::Version => {
7463 if version__.is_some() {
7464 return Err(serde::de::Error::duplicate_field("version"));
7465 }
7466 version__ = map_.next_value()?;
7467 }
7468 GeneratedField::VersionDeltas => {
7469 if version_deltas__.is_some() {
7470 return Err(serde::de::Error::duplicate_field("versionDeltas"));
7471 }
7472 version_deltas__ = Some(map_.next_value()?);
7473 }
7474 }
7475 }
7476 Ok(HummockVersionArchive {
7477 version: version__,
7478 version_deltas: version_deltas__.unwrap_or_default(),
7479 })
7480 }
7481 }
7482 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
7483 }
7484}
7485impl serde::Serialize for HummockVersionCheckpoint {
7486 #[allow(deprecated)]
7487 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7488 where
7489 S: serde::Serializer,
7490 {
7491 use serde::ser::SerializeStruct;
7492 let mut len = 0;
7493 if self.version.is_some() {
7494 len += 1;
7495 }
7496 if !self.stale_objects.is_empty() {
7497 len += 1;
7498 }
7499 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
7500 if let Some(v) = self.version.as_ref() {
7501 struct_ser.serialize_field("version", v)?;
7502 }
7503 if !self.stale_objects.is_empty() {
7504 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
7505 }
7506 struct_ser.end()
7507 }
7508}
7509impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
7510 #[allow(deprecated)]
7511 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7512 where
7513 D: serde::Deserializer<'de>,
7514 {
7515 const FIELDS: &[&str] = &[
7516 "version",
7517 "stale_objects",
7518 "staleObjects",
7519 ];
7520
7521 #[allow(clippy::enum_variant_names)]
7522 enum GeneratedField {
7523 Version,
7524 StaleObjects,
7525 }
7526 impl<'de> serde::Deserialize<'de> for GeneratedField {
7527 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7528 where
7529 D: serde::Deserializer<'de>,
7530 {
7531 struct GeneratedVisitor;
7532
7533 impl serde::de::Visitor<'_> for GeneratedVisitor {
7534 type Value = GeneratedField;
7535
7536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7537 write!(formatter, "expected one of: {:?}", &FIELDS)
7538 }
7539
7540 #[allow(unused_variables)]
7541 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7542 where
7543 E: serde::de::Error,
7544 {
7545 match value {
7546 "version" => Ok(GeneratedField::Version),
7547 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
7548 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7549 }
7550 }
7551 }
7552 deserializer.deserialize_identifier(GeneratedVisitor)
7553 }
7554 }
7555 struct GeneratedVisitor;
7556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7557 type Value = HummockVersionCheckpoint;
7558
7559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7560 formatter.write_str("struct hummock.HummockVersionCheckpoint")
7561 }
7562
7563 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
7564 where
7565 V: serde::de::MapAccess<'de>,
7566 {
7567 let mut version__ = None;
7568 let mut stale_objects__ = None;
7569 while let Some(k) = map_.next_key()? {
7570 match k {
7571 GeneratedField::Version => {
7572 if version__.is_some() {
7573 return Err(serde::de::Error::duplicate_field("version"));
7574 }
7575 version__ = map_.next_value()?;
7576 }
7577 GeneratedField::StaleObjects => {
7578 if stale_objects__.is_some() {
7579 return Err(serde::de::Error::duplicate_field("staleObjects"));
7580 }
7581 stale_objects__ = Some(
7582 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7583 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7584 );
7585 }
7586 }
7587 }
7588 Ok(HummockVersionCheckpoint {
7589 version: version__,
7590 stale_objects: stale_objects__.unwrap_or_default(),
7591 })
7592 }
7593 }
7594 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
7595 }
7596}
7597impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
7598 #[allow(deprecated)]
7599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7600 where
7601 S: serde::Serializer,
7602 {
7603 use serde::ser::SerializeStruct;
7604 let mut len = 0;
7605 if !self.id.is_empty() {
7606 len += 1;
7607 }
7608 if self.total_file_size != 0 {
7609 len += 1;
7610 }
7611 if !self.vector_files.is_empty() {
7612 len += 1;
7613 }
7614 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
7615 if !self.id.is_empty() {
7616 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7617 }
7618 if self.total_file_size != 0 {
7619 #[allow(clippy::needless_borrow)]
7620 #[allow(clippy::needless_borrows_for_generic_args)]
7621 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7622 }
7623 if !self.vector_files.is_empty() {
7624 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
7625 }
7626 struct_ser.end()
7627 }
7628}
7629impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
7630 #[allow(deprecated)]
7631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7632 where
7633 D: serde::Deserializer<'de>,
7634 {
7635 const FIELDS: &[&str] = &[
7636 "id",
7637 "total_file_size",
7638 "totalFileSize",
7639 "vector_files",
7640 "vectorFiles",
7641 ];
7642
7643 #[allow(clippy::enum_variant_names)]
7644 enum GeneratedField {
7645 Id,
7646 TotalFileSize,
7647 VectorFiles,
7648 }
7649 impl<'de> serde::Deserialize<'de> for GeneratedField {
7650 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7651 where
7652 D: serde::Deserializer<'de>,
7653 {
7654 struct GeneratedVisitor;
7655
7656 impl serde::de::Visitor<'_> for GeneratedVisitor {
7657 type Value = GeneratedField;
7658
7659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7660 write!(formatter, "expected one of: {:?}", &FIELDS)
7661 }
7662
7663 #[allow(unused_variables)]
7664 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7665 where
7666 E: serde::de::Error,
7667 {
7668 match value {
7669 "id" => Ok(GeneratedField::Id),
7670 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7671 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
7672 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7673 }
7674 }
7675 }
7676 deserializer.deserialize_identifier(GeneratedVisitor)
7677 }
7678 }
7679 struct GeneratedVisitor;
7680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7681 type Value = hummock_version_checkpoint::StaleObjects;
7682
7683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7684 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
7685 }
7686
7687 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
7688 where
7689 V: serde::de::MapAccess<'de>,
7690 {
7691 let mut id__ = None;
7692 let mut total_file_size__ = None;
7693 let mut vector_files__ = None;
7694 while let Some(k) = map_.next_key()? {
7695 match k {
7696 GeneratedField::Id => {
7697 if id__.is_some() {
7698 return Err(serde::de::Error::duplicate_field("id"));
7699 }
7700 id__ =
7701 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7702 .into_iter().map(|x| x.0).collect())
7703 ;
7704 }
7705 GeneratedField::TotalFileSize => {
7706 if total_file_size__.is_some() {
7707 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7708 }
7709 total_file_size__ =
7710 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7711 ;
7712 }
7713 GeneratedField::VectorFiles => {
7714 if vector_files__.is_some() {
7715 return Err(serde::de::Error::duplicate_field("vectorFiles"));
7716 }
7717 vector_files__ = Some(map_.next_value()?);
7718 }
7719 }
7720 }
7721 Ok(hummock_version_checkpoint::StaleObjects {
7722 id: id__.unwrap_or_default(),
7723 total_file_size: total_file_size__.unwrap_or_default(),
7724 vector_files: vector_files__.unwrap_or_default(),
7725 })
7726 }
7727 }
7728 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
7729 }
7730}
7731impl serde::Serialize for HummockVersionCheckpointEnvelope {
7732 #[allow(deprecated)]
7733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7734 where
7735 S: serde::Serializer,
7736 {
7737 use serde::ser::SerializeStruct;
7738 let mut len = 0;
7739 if self.compression_algorithm != 0 {
7740 len += 1;
7741 }
7742 if !self.payload.is_empty() {
7743 len += 1;
7744 }
7745 if self.checksum.is_some() {
7746 len += 1;
7747 }
7748 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpointEnvelope", len)?;
7749 if self.compression_algorithm != 0 {
7750 let v = CheckpointCompressionAlgorithm::try_from(self.compression_algorithm)
7751 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compression_algorithm)))?;
7752 struct_ser.serialize_field("compressionAlgorithm", &v)?;
7753 }
7754 if !self.payload.is_empty() {
7755 #[allow(clippy::needless_borrow)]
7756 #[allow(clippy::needless_borrows_for_generic_args)]
7757 struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?;
7758 }
7759 if let Some(v) = self.checksum.as_ref() {
7760 #[allow(clippy::needless_borrow)]
7761 #[allow(clippy::needless_borrows_for_generic_args)]
7762 struct_ser.serialize_field("checksum", ToString::to_string(&v).as_str())?;
7763 }
7764 struct_ser.end()
7765 }
7766}
7767impl<'de> serde::Deserialize<'de> for HummockVersionCheckpointEnvelope {
7768 #[allow(deprecated)]
7769 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7770 where
7771 D: serde::Deserializer<'de>,
7772 {
7773 const FIELDS: &[&str] = &[
7774 "compression_algorithm",
7775 "compressionAlgorithm",
7776 "payload",
7777 "checksum",
7778 ];
7779
7780 #[allow(clippy::enum_variant_names)]
7781 enum GeneratedField {
7782 CompressionAlgorithm,
7783 Payload,
7784 Checksum,
7785 }
7786 impl<'de> serde::Deserialize<'de> for GeneratedField {
7787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7788 where
7789 D: serde::Deserializer<'de>,
7790 {
7791 struct GeneratedVisitor;
7792
7793 impl serde::de::Visitor<'_> for GeneratedVisitor {
7794 type Value = GeneratedField;
7795
7796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7797 write!(formatter, "expected one of: {:?}", &FIELDS)
7798 }
7799
7800 #[allow(unused_variables)]
7801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7802 where
7803 E: serde::de::Error,
7804 {
7805 match value {
7806 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
7807 "payload" => Ok(GeneratedField::Payload),
7808 "checksum" => Ok(GeneratedField::Checksum),
7809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7810 }
7811 }
7812 }
7813 deserializer.deserialize_identifier(GeneratedVisitor)
7814 }
7815 }
7816 struct GeneratedVisitor;
7817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7818 type Value = HummockVersionCheckpointEnvelope;
7819
7820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7821 formatter.write_str("struct hummock.HummockVersionCheckpointEnvelope")
7822 }
7823
7824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpointEnvelope, V::Error>
7825 where
7826 V: serde::de::MapAccess<'de>,
7827 {
7828 let mut compression_algorithm__ = None;
7829 let mut payload__ = None;
7830 let mut checksum__ = None;
7831 while let Some(k) = map_.next_key()? {
7832 match k {
7833 GeneratedField::CompressionAlgorithm => {
7834 if compression_algorithm__.is_some() {
7835 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
7836 }
7837 compression_algorithm__ = Some(map_.next_value::<CheckpointCompressionAlgorithm>()? as i32);
7838 }
7839 GeneratedField::Payload => {
7840 if payload__.is_some() {
7841 return Err(serde::de::Error::duplicate_field("payload"));
7842 }
7843 payload__ =
7844 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7845 ;
7846 }
7847 GeneratedField::Checksum => {
7848 if checksum__.is_some() {
7849 return Err(serde::de::Error::duplicate_field("checksum"));
7850 }
7851 checksum__ =
7852 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7853 ;
7854 }
7855 }
7856 }
7857 Ok(HummockVersionCheckpointEnvelope {
7858 compression_algorithm: compression_algorithm__.unwrap_or_default(),
7859 payload: payload__.unwrap_or_default(),
7860 checksum: checksum__,
7861 })
7862 }
7863 }
7864 deserializer.deserialize_struct("hummock.HummockVersionCheckpointEnvelope", FIELDS, GeneratedVisitor)
7865 }
7866}
7867impl serde::Serialize for HummockVersionDelta {
7868 #[allow(deprecated)]
7869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7870 where
7871 S: serde::Serializer,
7872 {
7873 use serde::ser::SerializeStruct;
7874 let mut len = 0;
7875 if self.id != 0 {
7876 len += 1;
7877 }
7878 if self.prev_id != 0 {
7879 len += 1;
7880 }
7881 if !self.group_deltas.is_empty() {
7882 len += 1;
7883 }
7884 if self.max_committed_epoch != 0 {
7885 len += 1;
7886 }
7887 if self.trivial_move {
7888 len += 1;
7889 }
7890 if !self.new_table_watermarks.is_empty() {
7891 len += 1;
7892 }
7893 if !self.removed_table_ids.is_empty() {
7894 len += 1;
7895 }
7896 if !self.change_log_delta.is_empty() {
7897 len += 1;
7898 }
7899 if !self.state_table_info_delta.is_empty() {
7900 len += 1;
7901 }
7902 if !self.vector_index_delta.is_empty() {
7903 len += 1;
7904 }
7905 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
7906 if self.id != 0 {
7907 #[allow(clippy::needless_borrow)]
7908 #[allow(clippy::needless_borrows_for_generic_args)]
7909 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7910 }
7911 if self.prev_id != 0 {
7912 #[allow(clippy::needless_borrow)]
7913 #[allow(clippy::needless_borrows_for_generic_args)]
7914 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
7915 }
7916 if !self.group_deltas.is_empty() {
7917 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7918 }
7919 if self.max_committed_epoch != 0 {
7920 #[allow(clippy::needless_borrow)]
7921 #[allow(clippy::needless_borrows_for_generic_args)]
7922 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
7923 }
7924 if self.trivial_move {
7925 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
7926 }
7927 if !self.new_table_watermarks.is_empty() {
7928 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
7929 }
7930 if !self.removed_table_ids.is_empty() {
7931 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
7932 }
7933 if !self.change_log_delta.is_empty() {
7934 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
7935 }
7936 if !self.state_table_info_delta.is_empty() {
7937 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
7938 }
7939 if !self.vector_index_delta.is_empty() {
7940 struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
7941 }
7942 struct_ser.end()
7943 }
7944}
7945impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
7946 #[allow(deprecated)]
7947 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7948 where
7949 D: serde::Deserializer<'de>,
7950 {
7951 const FIELDS: &[&str] = &[
7952 "id",
7953 "prev_id",
7954 "prevId",
7955 "group_deltas",
7956 "groupDeltas",
7957 "max_committed_epoch",
7958 "maxCommittedEpoch",
7959 "trivial_move",
7960 "trivialMove",
7961 "new_table_watermarks",
7962 "newTableWatermarks",
7963 "removed_table_ids",
7964 "removedTableIds",
7965 "change_log_delta",
7966 "changeLogDelta",
7967 "state_table_info_delta",
7968 "stateTableInfoDelta",
7969 "vector_index_delta",
7970 "vectorIndexDelta",
7971 ];
7972
7973 #[allow(clippy::enum_variant_names)]
7974 enum GeneratedField {
7975 Id,
7976 PrevId,
7977 GroupDeltas,
7978 MaxCommittedEpoch,
7979 TrivialMove,
7980 NewTableWatermarks,
7981 RemovedTableIds,
7982 ChangeLogDelta,
7983 StateTableInfoDelta,
7984 VectorIndexDelta,
7985 }
7986 impl<'de> serde::Deserialize<'de> for GeneratedField {
7987 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7988 where
7989 D: serde::Deserializer<'de>,
7990 {
7991 struct GeneratedVisitor;
7992
7993 impl serde::de::Visitor<'_> for GeneratedVisitor {
7994 type Value = GeneratedField;
7995
7996 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7997 write!(formatter, "expected one of: {:?}", &FIELDS)
7998 }
7999
8000 #[allow(unused_variables)]
8001 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8002 where
8003 E: serde::de::Error,
8004 {
8005 match value {
8006 "id" => Ok(GeneratedField::Id),
8007 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
8008 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
8009 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
8010 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
8011 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
8012 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
8013 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
8014 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
8015 "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
8016 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8017 }
8018 }
8019 }
8020 deserializer.deserialize_identifier(GeneratedVisitor)
8021 }
8022 }
8023 struct GeneratedVisitor;
8024 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8025 type Value = HummockVersionDelta;
8026
8027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8028 formatter.write_str("struct hummock.HummockVersionDelta")
8029 }
8030
8031 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
8032 where
8033 V: serde::de::MapAccess<'de>,
8034 {
8035 let mut id__ = None;
8036 let mut prev_id__ = None;
8037 let mut group_deltas__ = None;
8038 let mut max_committed_epoch__ = None;
8039 let mut trivial_move__ = None;
8040 let mut new_table_watermarks__ = None;
8041 let mut removed_table_ids__ = None;
8042 let mut change_log_delta__ = None;
8043 let mut state_table_info_delta__ = None;
8044 let mut vector_index_delta__ = None;
8045 while let Some(k) = map_.next_key()? {
8046 match k {
8047 GeneratedField::Id => {
8048 if id__.is_some() {
8049 return Err(serde::de::Error::duplicate_field("id"));
8050 }
8051 id__ =
8052 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8053 ;
8054 }
8055 GeneratedField::PrevId => {
8056 if prev_id__.is_some() {
8057 return Err(serde::de::Error::duplicate_field("prevId"));
8058 }
8059 prev_id__ =
8060 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8061 ;
8062 }
8063 GeneratedField::GroupDeltas => {
8064 if group_deltas__.is_some() {
8065 return Err(serde::de::Error::duplicate_field("groupDeltas"));
8066 }
8067 group_deltas__ = Some(
8068 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
8069 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8070 );
8071 }
8072 GeneratedField::MaxCommittedEpoch => {
8073 if max_committed_epoch__.is_some() {
8074 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
8075 }
8076 max_committed_epoch__ =
8077 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8078 ;
8079 }
8080 GeneratedField::TrivialMove => {
8081 if trivial_move__.is_some() {
8082 return Err(serde::de::Error::duplicate_field("trivialMove"));
8083 }
8084 trivial_move__ = Some(map_.next_value()?);
8085 }
8086 GeneratedField::NewTableWatermarks => {
8087 if new_table_watermarks__.is_some() {
8088 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
8089 }
8090 new_table_watermarks__ = Some(
8091 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8092 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8093 );
8094 }
8095 GeneratedField::RemovedTableIds => {
8096 if removed_table_ids__.is_some() {
8097 return Err(serde::de::Error::duplicate_field("removedTableIds"));
8098 }
8099 removed_table_ids__ =
8100 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8101 .into_iter().map(|x| x.0).collect())
8102 ;
8103 }
8104 GeneratedField::ChangeLogDelta => {
8105 if change_log_delta__.is_some() {
8106 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
8107 }
8108 change_log_delta__ = Some(
8109 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8110 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8111 );
8112 }
8113 GeneratedField::StateTableInfoDelta => {
8114 if state_table_info_delta__.is_some() {
8115 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
8116 }
8117 state_table_info_delta__ = Some(
8118 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8119 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8120 );
8121 }
8122 GeneratedField::VectorIndexDelta => {
8123 if vector_index_delta__.is_some() {
8124 return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
8125 }
8126 vector_index_delta__ = Some(
8127 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8128 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8129 );
8130 }
8131 }
8132 }
8133 Ok(HummockVersionDelta {
8134 id: id__.unwrap_or_default(),
8135 prev_id: prev_id__.unwrap_or_default(),
8136 group_deltas: group_deltas__.unwrap_or_default(),
8137 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
8138 trivial_move: trivial_move__.unwrap_or_default(),
8139 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
8140 removed_table_ids: removed_table_ids__.unwrap_or_default(),
8141 change_log_delta: change_log_delta__.unwrap_or_default(),
8142 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
8143 vector_index_delta: vector_index_delta__.unwrap_or_default(),
8144 })
8145 }
8146 }
8147 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
8148 }
8149}
8150impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
8151 #[allow(deprecated)]
8152 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8153 where
8154 S: serde::Serializer,
8155 {
8156 use serde::ser::SerializeStruct;
8157 let mut len = 0;
8158 if self.new_log.is_some() {
8159 len += 1;
8160 }
8161 if self.truncate_epoch != 0 {
8162 len += 1;
8163 }
8164 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
8165 if let Some(v) = self.new_log.as_ref() {
8166 struct_ser.serialize_field("newLog", v)?;
8167 }
8168 if self.truncate_epoch != 0 {
8169 #[allow(clippy::needless_borrow)]
8170 #[allow(clippy::needless_borrows_for_generic_args)]
8171 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
8172 }
8173 struct_ser.end()
8174 }
8175}
8176impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
8177 #[allow(deprecated)]
8178 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8179 where
8180 D: serde::Deserializer<'de>,
8181 {
8182 const FIELDS: &[&str] = &[
8183 "new_log",
8184 "newLog",
8185 "truncate_epoch",
8186 "truncateEpoch",
8187 ];
8188
8189 #[allow(clippy::enum_variant_names)]
8190 enum GeneratedField {
8191 NewLog,
8192 TruncateEpoch,
8193 }
8194 impl<'de> serde::Deserialize<'de> for GeneratedField {
8195 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8196 where
8197 D: serde::Deserializer<'de>,
8198 {
8199 struct GeneratedVisitor;
8200
8201 impl serde::de::Visitor<'_> for GeneratedVisitor {
8202 type Value = GeneratedField;
8203
8204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8205 write!(formatter, "expected one of: {:?}", &FIELDS)
8206 }
8207
8208 #[allow(unused_variables)]
8209 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8210 where
8211 E: serde::de::Error,
8212 {
8213 match value {
8214 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
8215 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
8216 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8217 }
8218 }
8219 }
8220 deserializer.deserialize_identifier(GeneratedVisitor)
8221 }
8222 }
8223 struct GeneratedVisitor;
8224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8225 type Value = hummock_version_delta::ChangeLogDelta;
8226
8227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8228 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
8229 }
8230
8231 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
8232 where
8233 V: serde::de::MapAccess<'de>,
8234 {
8235 let mut new_log__ = None;
8236 let mut truncate_epoch__ = None;
8237 while let Some(k) = map_.next_key()? {
8238 match k {
8239 GeneratedField::NewLog => {
8240 if new_log__.is_some() {
8241 return Err(serde::de::Error::duplicate_field("newLog"));
8242 }
8243 new_log__ = map_.next_value()?;
8244 }
8245 GeneratedField::TruncateEpoch => {
8246 if truncate_epoch__.is_some() {
8247 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
8248 }
8249 truncate_epoch__ =
8250 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8251 ;
8252 }
8253 }
8254 }
8255 Ok(hummock_version_delta::ChangeLogDelta {
8256 new_log: new_log__,
8257 truncate_epoch: truncate_epoch__.unwrap_or_default(),
8258 })
8259 }
8260 }
8261 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
8262 }
8263}
8264impl serde::Serialize for hummock_version_delta::GroupDeltas {
8265 #[allow(deprecated)]
8266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8267 where
8268 S: serde::Serializer,
8269 {
8270 use serde::ser::SerializeStruct;
8271 let mut len = 0;
8272 if !self.group_deltas.is_empty() {
8273 len += 1;
8274 }
8275 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
8276 if !self.group_deltas.is_empty() {
8277 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
8278 }
8279 struct_ser.end()
8280 }
8281}
8282impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
8283 #[allow(deprecated)]
8284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8285 where
8286 D: serde::Deserializer<'de>,
8287 {
8288 const FIELDS: &[&str] = &[
8289 "group_deltas",
8290 "groupDeltas",
8291 ];
8292
8293 #[allow(clippy::enum_variant_names)]
8294 enum GeneratedField {
8295 GroupDeltas,
8296 }
8297 impl<'de> serde::Deserialize<'de> for GeneratedField {
8298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8299 where
8300 D: serde::Deserializer<'de>,
8301 {
8302 struct GeneratedVisitor;
8303
8304 impl serde::de::Visitor<'_> for GeneratedVisitor {
8305 type Value = GeneratedField;
8306
8307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8308 write!(formatter, "expected one of: {:?}", &FIELDS)
8309 }
8310
8311 #[allow(unused_variables)]
8312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8313 where
8314 E: serde::de::Error,
8315 {
8316 match value {
8317 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
8318 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8319 }
8320 }
8321 }
8322 deserializer.deserialize_identifier(GeneratedVisitor)
8323 }
8324 }
8325 struct GeneratedVisitor;
8326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8327 type Value = hummock_version_delta::GroupDeltas;
8328
8329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8330 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
8331 }
8332
8333 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
8334 where
8335 V: serde::de::MapAccess<'de>,
8336 {
8337 let mut group_deltas__ = None;
8338 while let Some(k) = map_.next_key()? {
8339 match k {
8340 GeneratedField::GroupDeltas => {
8341 if group_deltas__.is_some() {
8342 return Err(serde::de::Error::duplicate_field("groupDeltas"));
8343 }
8344 group_deltas__ = Some(map_.next_value()?);
8345 }
8346 }
8347 }
8348 Ok(hummock_version_delta::GroupDeltas {
8349 group_deltas: group_deltas__.unwrap_or_default(),
8350 })
8351 }
8352 }
8353 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
8354 }
8355}
8356impl serde::Serialize for HummockVersionDeltas {
8357 #[allow(deprecated)]
8358 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8359 where
8360 S: serde::Serializer,
8361 {
8362 use serde::ser::SerializeStruct;
8363 let mut len = 0;
8364 if !self.version_deltas.is_empty() {
8365 len += 1;
8366 }
8367 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
8368 if !self.version_deltas.is_empty() {
8369 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
8370 }
8371 struct_ser.end()
8372 }
8373}
8374impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
8375 #[allow(deprecated)]
8376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8377 where
8378 D: serde::Deserializer<'de>,
8379 {
8380 const FIELDS: &[&str] = &[
8381 "version_deltas",
8382 "versionDeltas",
8383 ];
8384
8385 #[allow(clippy::enum_variant_names)]
8386 enum GeneratedField {
8387 VersionDeltas,
8388 }
8389 impl<'de> serde::Deserialize<'de> for GeneratedField {
8390 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8391 where
8392 D: serde::Deserializer<'de>,
8393 {
8394 struct GeneratedVisitor;
8395
8396 impl serde::de::Visitor<'_> for GeneratedVisitor {
8397 type Value = GeneratedField;
8398
8399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8400 write!(formatter, "expected one of: {:?}", &FIELDS)
8401 }
8402
8403 #[allow(unused_variables)]
8404 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8405 where
8406 E: serde::de::Error,
8407 {
8408 match value {
8409 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
8410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8411 }
8412 }
8413 }
8414 deserializer.deserialize_identifier(GeneratedVisitor)
8415 }
8416 }
8417 struct GeneratedVisitor;
8418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8419 type Value = HummockVersionDeltas;
8420
8421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8422 formatter.write_str("struct hummock.HummockVersionDeltas")
8423 }
8424
8425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
8426 where
8427 V: serde::de::MapAccess<'de>,
8428 {
8429 let mut version_deltas__ = None;
8430 while let Some(k) = map_.next_key()? {
8431 match k {
8432 GeneratedField::VersionDeltas => {
8433 if version_deltas__.is_some() {
8434 return Err(serde::de::Error::duplicate_field("versionDeltas"));
8435 }
8436 version_deltas__ = Some(map_.next_value()?);
8437 }
8438 }
8439 }
8440 Ok(HummockVersionDeltas {
8441 version_deltas: version_deltas__.unwrap_or_default(),
8442 })
8443 }
8444 }
8445 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
8446 }
8447}
8448impl serde::Serialize for HummockVersionStats {
8449 #[allow(deprecated)]
8450 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8451 where
8452 S: serde::Serializer,
8453 {
8454 use serde::ser::SerializeStruct;
8455 let mut len = 0;
8456 if self.hummock_version_id != 0 {
8457 len += 1;
8458 }
8459 if !self.table_stats.is_empty() {
8460 len += 1;
8461 }
8462 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
8463 if self.hummock_version_id != 0 {
8464 #[allow(clippy::needless_borrow)]
8465 #[allow(clippy::needless_borrows_for_generic_args)]
8466 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
8467 }
8468 if !self.table_stats.is_empty() {
8469 struct_ser.serialize_field("tableStats", &self.table_stats)?;
8470 }
8471 struct_ser.end()
8472 }
8473}
8474impl<'de> serde::Deserialize<'de> for HummockVersionStats {
8475 #[allow(deprecated)]
8476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8477 where
8478 D: serde::Deserializer<'de>,
8479 {
8480 const FIELDS: &[&str] = &[
8481 "hummock_version_id",
8482 "hummockVersionId",
8483 "table_stats",
8484 "tableStats",
8485 ];
8486
8487 #[allow(clippy::enum_variant_names)]
8488 enum GeneratedField {
8489 HummockVersionId,
8490 TableStats,
8491 }
8492 impl<'de> serde::Deserialize<'de> for GeneratedField {
8493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8494 where
8495 D: serde::Deserializer<'de>,
8496 {
8497 struct GeneratedVisitor;
8498
8499 impl serde::de::Visitor<'_> for GeneratedVisitor {
8500 type Value = GeneratedField;
8501
8502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8503 write!(formatter, "expected one of: {:?}", &FIELDS)
8504 }
8505
8506 #[allow(unused_variables)]
8507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8508 where
8509 E: serde::de::Error,
8510 {
8511 match value {
8512 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
8513 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
8514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8515 }
8516 }
8517 }
8518 deserializer.deserialize_identifier(GeneratedVisitor)
8519 }
8520 }
8521 struct GeneratedVisitor;
8522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8523 type Value = HummockVersionStats;
8524
8525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8526 formatter.write_str("struct hummock.HummockVersionStats")
8527 }
8528
8529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
8530 where
8531 V: serde::de::MapAccess<'de>,
8532 {
8533 let mut hummock_version_id__ = None;
8534 let mut table_stats__ = None;
8535 while let Some(k) = map_.next_key()? {
8536 match k {
8537 GeneratedField::HummockVersionId => {
8538 if hummock_version_id__.is_some() {
8539 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
8540 }
8541 hummock_version_id__ =
8542 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8543 ;
8544 }
8545 GeneratedField::TableStats => {
8546 if table_stats__.is_some() {
8547 return Err(serde::de::Error::duplicate_field("tableStats"));
8548 }
8549 table_stats__ = Some(
8550 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8551 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8552 );
8553 }
8554 }
8555 }
8556 Ok(HummockVersionStats {
8557 hummock_version_id: hummock_version_id__.unwrap_or_default(),
8558 table_stats: table_stats__.unwrap_or_default(),
8559 })
8560 }
8561 }
8562 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
8563 }
8564}
8565impl serde::Serialize for InitMetadataForReplayRequest {
8566 #[allow(deprecated)]
8567 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8568 where
8569 S: serde::Serializer,
8570 {
8571 use serde::ser::SerializeStruct;
8572 let mut len = 0;
8573 if !self.tables.is_empty() {
8574 len += 1;
8575 }
8576 if !self.compaction_groups.is_empty() {
8577 len += 1;
8578 }
8579 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
8580 if !self.tables.is_empty() {
8581 struct_ser.serialize_field("tables", &self.tables)?;
8582 }
8583 if !self.compaction_groups.is_empty() {
8584 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
8585 }
8586 struct_ser.end()
8587 }
8588}
8589impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
8590 #[allow(deprecated)]
8591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8592 where
8593 D: serde::Deserializer<'de>,
8594 {
8595 const FIELDS: &[&str] = &[
8596 "tables",
8597 "compaction_groups",
8598 "compactionGroups",
8599 ];
8600
8601 #[allow(clippy::enum_variant_names)]
8602 enum GeneratedField {
8603 Tables,
8604 CompactionGroups,
8605 }
8606 impl<'de> serde::Deserialize<'de> for GeneratedField {
8607 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8608 where
8609 D: serde::Deserializer<'de>,
8610 {
8611 struct GeneratedVisitor;
8612
8613 impl serde::de::Visitor<'_> for GeneratedVisitor {
8614 type Value = GeneratedField;
8615
8616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8617 write!(formatter, "expected one of: {:?}", &FIELDS)
8618 }
8619
8620 #[allow(unused_variables)]
8621 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8622 where
8623 E: serde::de::Error,
8624 {
8625 match value {
8626 "tables" => Ok(GeneratedField::Tables),
8627 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
8628 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8629 }
8630 }
8631 }
8632 deserializer.deserialize_identifier(GeneratedVisitor)
8633 }
8634 }
8635 struct GeneratedVisitor;
8636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8637 type Value = InitMetadataForReplayRequest;
8638
8639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8640 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
8641 }
8642
8643 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
8644 where
8645 V: serde::de::MapAccess<'de>,
8646 {
8647 let mut tables__ = None;
8648 let mut compaction_groups__ = None;
8649 while let Some(k) = map_.next_key()? {
8650 match k {
8651 GeneratedField::Tables => {
8652 if tables__.is_some() {
8653 return Err(serde::de::Error::duplicate_field("tables"));
8654 }
8655 tables__ = Some(map_.next_value()?);
8656 }
8657 GeneratedField::CompactionGroups => {
8658 if compaction_groups__.is_some() {
8659 return Err(serde::de::Error::duplicate_field("compactionGroups"));
8660 }
8661 compaction_groups__ = Some(map_.next_value()?);
8662 }
8663 }
8664 }
8665 Ok(InitMetadataForReplayRequest {
8666 tables: tables__.unwrap_or_default(),
8667 compaction_groups: compaction_groups__.unwrap_or_default(),
8668 })
8669 }
8670 }
8671 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
8672 }
8673}
8674impl serde::Serialize for InitMetadataForReplayResponse {
8675 #[allow(deprecated)]
8676 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8677 where
8678 S: serde::Serializer,
8679 {
8680 use serde::ser::SerializeStruct;
8681 let len = 0;
8682 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
8683 struct_ser.end()
8684 }
8685}
8686impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
8687 #[allow(deprecated)]
8688 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8689 where
8690 D: serde::Deserializer<'de>,
8691 {
8692 const FIELDS: &[&str] = &[
8693 ];
8694
8695 #[allow(clippy::enum_variant_names)]
8696 enum GeneratedField {
8697 }
8698 impl<'de> serde::Deserialize<'de> for GeneratedField {
8699 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8700 where
8701 D: serde::Deserializer<'de>,
8702 {
8703 struct GeneratedVisitor;
8704
8705 impl serde::de::Visitor<'_> for GeneratedVisitor {
8706 type Value = GeneratedField;
8707
8708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8709 write!(formatter, "expected one of: {:?}", &FIELDS)
8710 }
8711
8712 #[allow(unused_variables)]
8713 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8714 where
8715 E: serde::de::Error,
8716 {
8717 Err(serde::de::Error::unknown_field(value, FIELDS))
8718 }
8719 }
8720 deserializer.deserialize_identifier(GeneratedVisitor)
8721 }
8722 }
8723 struct GeneratedVisitor;
8724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8725 type Value = InitMetadataForReplayResponse;
8726
8727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8728 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
8729 }
8730
8731 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
8732 where
8733 V: serde::de::MapAccess<'de>,
8734 {
8735 while map_.next_key::<GeneratedField>()?.is_some() {
8736 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8737 }
8738 Ok(InitMetadataForReplayResponse {
8739 })
8740 }
8741 }
8742 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
8743 }
8744}
8745impl serde::Serialize for InputLevel {
8746 #[allow(deprecated)]
8747 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8748 where
8749 S: serde::Serializer,
8750 {
8751 use serde::ser::SerializeStruct;
8752 let mut len = 0;
8753 if self.level_idx != 0 {
8754 len += 1;
8755 }
8756 if self.level_type != 0 {
8757 len += 1;
8758 }
8759 if !self.table_infos.is_empty() {
8760 len += 1;
8761 }
8762 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
8763 if self.level_idx != 0 {
8764 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8765 }
8766 if self.level_type != 0 {
8767 let v = LevelType::try_from(self.level_type)
8768 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
8769 struct_ser.serialize_field("levelType", &v)?;
8770 }
8771 if !self.table_infos.is_empty() {
8772 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
8773 }
8774 struct_ser.end()
8775 }
8776}
8777impl<'de> serde::Deserialize<'de> for InputLevel {
8778 #[allow(deprecated)]
8779 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8780 where
8781 D: serde::Deserializer<'de>,
8782 {
8783 const FIELDS: &[&str] = &[
8784 "level_idx",
8785 "levelIdx",
8786 "level_type",
8787 "levelType",
8788 "table_infos",
8789 "tableInfos",
8790 ];
8791
8792 #[allow(clippy::enum_variant_names)]
8793 enum GeneratedField {
8794 LevelIdx,
8795 LevelType,
8796 TableInfos,
8797 }
8798 impl<'de> serde::Deserialize<'de> for GeneratedField {
8799 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8800 where
8801 D: serde::Deserializer<'de>,
8802 {
8803 struct GeneratedVisitor;
8804
8805 impl serde::de::Visitor<'_> for GeneratedVisitor {
8806 type Value = GeneratedField;
8807
8808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8809 write!(formatter, "expected one of: {:?}", &FIELDS)
8810 }
8811
8812 #[allow(unused_variables)]
8813 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8814 where
8815 E: serde::de::Error,
8816 {
8817 match value {
8818 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8819 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8820 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8821 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8822 }
8823 }
8824 }
8825 deserializer.deserialize_identifier(GeneratedVisitor)
8826 }
8827 }
8828 struct GeneratedVisitor;
8829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8830 type Value = InputLevel;
8831
8832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8833 formatter.write_str("struct hummock.InputLevel")
8834 }
8835
8836 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
8837 where
8838 V: serde::de::MapAccess<'de>,
8839 {
8840 let mut level_idx__ = None;
8841 let mut level_type__ = None;
8842 let mut table_infos__ = None;
8843 while let Some(k) = map_.next_key()? {
8844 match k {
8845 GeneratedField::LevelIdx => {
8846 if level_idx__.is_some() {
8847 return Err(serde::de::Error::duplicate_field("levelIdx"));
8848 }
8849 level_idx__ =
8850 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8851 ;
8852 }
8853 GeneratedField::LevelType => {
8854 if level_type__.is_some() {
8855 return Err(serde::de::Error::duplicate_field("levelType"));
8856 }
8857 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8858 }
8859 GeneratedField::TableInfos => {
8860 if table_infos__.is_some() {
8861 return Err(serde::de::Error::duplicate_field("tableInfos"));
8862 }
8863 table_infos__ = Some(map_.next_value()?);
8864 }
8865 }
8866 }
8867 Ok(InputLevel {
8868 level_idx: level_idx__.unwrap_or_default(),
8869 level_type: level_type__.unwrap_or_default(),
8870 table_infos: table_infos__.unwrap_or_default(),
8871 })
8872 }
8873 }
8874 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
8875 }
8876}
8877impl serde::Serialize for IntraLevelDelta {
8878 #[allow(deprecated)]
8879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8880 where
8881 S: serde::Serializer,
8882 {
8883 use serde::ser::SerializeStruct;
8884 let mut len = 0;
8885 if self.level_idx != 0 {
8886 len += 1;
8887 }
8888 if self.l0_sub_level_id != 0 {
8889 len += 1;
8890 }
8891 if !self.removed_table_ids.is_empty() {
8892 len += 1;
8893 }
8894 if !self.inserted_table_infos.is_empty() {
8895 len += 1;
8896 }
8897 if self.vnode_partition_count != 0 {
8898 len += 1;
8899 }
8900 if self.compaction_group_version_id != 0 {
8901 len += 1;
8902 }
8903 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
8904 if self.level_idx != 0 {
8905 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8906 }
8907 if self.l0_sub_level_id != 0 {
8908 #[allow(clippy::needless_borrow)]
8909 #[allow(clippy::needless_borrows_for_generic_args)]
8910 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
8911 }
8912 if !self.removed_table_ids.is_empty() {
8913 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8914 }
8915 if !self.inserted_table_infos.is_empty() {
8916 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
8917 }
8918 if self.vnode_partition_count != 0 {
8919 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8920 }
8921 if self.compaction_group_version_id != 0 {
8922 #[allow(clippy::needless_borrow)]
8923 #[allow(clippy::needless_borrows_for_generic_args)]
8924 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
8925 }
8926 struct_ser.end()
8927 }
8928}
8929impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
8930 #[allow(deprecated)]
8931 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8932 where
8933 D: serde::Deserializer<'de>,
8934 {
8935 const FIELDS: &[&str] = &[
8936 "level_idx",
8937 "levelIdx",
8938 "l0_sub_level_id",
8939 "l0SubLevelId",
8940 "removed_table_ids",
8941 "removedTableIds",
8942 "inserted_table_infos",
8943 "insertedTableInfos",
8944 "vnode_partition_count",
8945 "vnodePartitionCount",
8946 "compaction_group_version_id",
8947 "compactionGroupVersionId",
8948 ];
8949
8950 #[allow(clippy::enum_variant_names)]
8951 enum GeneratedField {
8952 LevelIdx,
8953 L0SubLevelId,
8954 RemovedTableIds,
8955 InsertedTableInfos,
8956 VnodePartitionCount,
8957 CompactionGroupVersionId,
8958 }
8959 impl<'de> serde::Deserialize<'de> for GeneratedField {
8960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8961 where
8962 D: serde::Deserializer<'de>,
8963 {
8964 struct GeneratedVisitor;
8965
8966 impl serde::de::Visitor<'_> for GeneratedVisitor {
8967 type Value = GeneratedField;
8968
8969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8970 write!(formatter, "expected one of: {:?}", &FIELDS)
8971 }
8972
8973 #[allow(unused_variables)]
8974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8975 where
8976 E: serde::de::Error,
8977 {
8978 match value {
8979 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8980 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
8981 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
8982 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
8983 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8984 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
8985 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8986 }
8987 }
8988 }
8989 deserializer.deserialize_identifier(GeneratedVisitor)
8990 }
8991 }
8992 struct GeneratedVisitor;
8993 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8994 type Value = IntraLevelDelta;
8995
8996 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8997 formatter.write_str("struct hummock.IntraLevelDelta")
8998 }
8999
9000 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
9001 where
9002 V: serde::de::MapAccess<'de>,
9003 {
9004 let mut level_idx__ = None;
9005 let mut l0_sub_level_id__ = None;
9006 let mut removed_table_ids__ = None;
9007 let mut inserted_table_infos__ = None;
9008 let mut vnode_partition_count__ = None;
9009 let mut compaction_group_version_id__ = None;
9010 while let Some(k) = map_.next_key()? {
9011 match k {
9012 GeneratedField::LevelIdx => {
9013 if level_idx__.is_some() {
9014 return Err(serde::de::Error::duplicate_field("levelIdx"));
9015 }
9016 level_idx__ =
9017 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9018 ;
9019 }
9020 GeneratedField::L0SubLevelId => {
9021 if l0_sub_level_id__.is_some() {
9022 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
9023 }
9024 l0_sub_level_id__ =
9025 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9026 ;
9027 }
9028 GeneratedField::RemovedTableIds => {
9029 if removed_table_ids__.is_some() {
9030 return Err(serde::de::Error::duplicate_field("removedTableIds"));
9031 }
9032 removed_table_ids__ =
9033 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9034 .into_iter().map(|x| x.0).collect())
9035 ;
9036 }
9037 GeneratedField::InsertedTableInfos => {
9038 if inserted_table_infos__.is_some() {
9039 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
9040 }
9041 inserted_table_infos__ = Some(map_.next_value()?);
9042 }
9043 GeneratedField::VnodePartitionCount => {
9044 if vnode_partition_count__.is_some() {
9045 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
9046 }
9047 vnode_partition_count__ =
9048 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9049 ;
9050 }
9051 GeneratedField::CompactionGroupVersionId => {
9052 if compaction_group_version_id__.is_some() {
9053 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
9054 }
9055 compaction_group_version_id__ =
9056 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9057 ;
9058 }
9059 }
9060 }
9061 Ok(IntraLevelDelta {
9062 level_idx: level_idx__.unwrap_or_default(),
9063 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
9064 removed_table_ids: removed_table_ids__.unwrap_or_default(),
9065 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
9066 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
9067 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
9068 })
9069 }
9070 }
9071 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
9072 }
9073}
9074impl serde::Serialize for KeyRange {
9075 #[allow(deprecated)]
9076 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9077 where
9078 S: serde::Serializer,
9079 {
9080 use serde::ser::SerializeStruct;
9081 let mut len = 0;
9082 if !self.left.is_empty() {
9083 len += 1;
9084 }
9085 if !self.right.is_empty() {
9086 len += 1;
9087 }
9088 if self.right_exclusive {
9089 len += 1;
9090 }
9091 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
9092 if !self.left.is_empty() {
9093 #[allow(clippy::needless_borrow)]
9094 #[allow(clippy::needless_borrows_for_generic_args)]
9095 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
9096 }
9097 if !self.right.is_empty() {
9098 #[allow(clippy::needless_borrow)]
9099 #[allow(clippy::needless_borrows_for_generic_args)]
9100 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
9101 }
9102 if self.right_exclusive {
9103 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
9104 }
9105 struct_ser.end()
9106 }
9107}
9108impl<'de> serde::Deserialize<'de> for KeyRange {
9109 #[allow(deprecated)]
9110 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9111 where
9112 D: serde::Deserializer<'de>,
9113 {
9114 const FIELDS: &[&str] = &[
9115 "left",
9116 "right",
9117 "right_exclusive",
9118 "rightExclusive",
9119 ];
9120
9121 #[allow(clippy::enum_variant_names)]
9122 enum GeneratedField {
9123 Left,
9124 Right,
9125 RightExclusive,
9126 }
9127 impl<'de> serde::Deserialize<'de> for GeneratedField {
9128 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9129 where
9130 D: serde::Deserializer<'de>,
9131 {
9132 struct GeneratedVisitor;
9133
9134 impl serde::de::Visitor<'_> for GeneratedVisitor {
9135 type Value = GeneratedField;
9136
9137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9138 write!(formatter, "expected one of: {:?}", &FIELDS)
9139 }
9140
9141 #[allow(unused_variables)]
9142 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9143 where
9144 E: serde::de::Error,
9145 {
9146 match value {
9147 "left" => Ok(GeneratedField::Left),
9148 "right" => Ok(GeneratedField::Right),
9149 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
9150 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9151 }
9152 }
9153 }
9154 deserializer.deserialize_identifier(GeneratedVisitor)
9155 }
9156 }
9157 struct GeneratedVisitor;
9158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9159 type Value = KeyRange;
9160
9161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9162 formatter.write_str("struct hummock.KeyRange")
9163 }
9164
9165 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
9166 where
9167 V: serde::de::MapAccess<'de>,
9168 {
9169 let mut left__ = None;
9170 let mut right__ = None;
9171 let mut right_exclusive__ = None;
9172 while let Some(k) = map_.next_key()? {
9173 match k {
9174 GeneratedField::Left => {
9175 if left__.is_some() {
9176 return Err(serde::de::Error::duplicate_field("left"));
9177 }
9178 left__ =
9179 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
9180 ;
9181 }
9182 GeneratedField::Right => {
9183 if right__.is_some() {
9184 return Err(serde::de::Error::duplicate_field("right"));
9185 }
9186 right__ =
9187 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
9188 ;
9189 }
9190 GeneratedField::RightExclusive => {
9191 if right_exclusive__.is_some() {
9192 return Err(serde::de::Error::duplicate_field("rightExclusive"));
9193 }
9194 right_exclusive__ = Some(map_.next_value()?);
9195 }
9196 }
9197 }
9198 Ok(KeyRange {
9199 left: left__.unwrap_or_default(),
9200 right: right__.unwrap_or_default(),
9201 right_exclusive: right_exclusive__.unwrap_or_default(),
9202 })
9203 }
9204 }
9205 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
9206 }
9207}
9208impl serde::Serialize for Level {
9209 #[allow(deprecated)]
9210 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9211 where
9212 S: serde::Serializer,
9213 {
9214 use serde::ser::SerializeStruct;
9215 let mut len = 0;
9216 if self.level_idx != 0 {
9217 len += 1;
9218 }
9219 if self.level_type != 0 {
9220 len += 1;
9221 }
9222 if !self.table_infos.is_empty() {
9223 len += 1;
9224 }
9225 if self.total_file_size != 0 {
9226 len += 1;
9227 }
9228 if self.sub_level_id != 0 {
9229 len += 1;
9230 }
9231 if self.uncompressed_file_size != 0 {
9232 len += 1;
9233 }
9234 if self.vnode_partition_count != 0 {
9235 len += 1;
9236 }
9237 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
9238 if self.level_idx != 0 {
9239 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
9240 }
9241 if self.level_type != 0 {
9242 let v = LevelType::try_from(self.level_type)
9243 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
9244 struct_ser.serialize_field("levelType", &v)?;
9245 }
9246 if !self.table_infos.is_empty() {
9247 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
9248 }
9249 if self.total_file_size != 0 {
9250 #[allow(clippy::needless_borrow)]
9251 #[allow(clippy::needless_borrows_for_generic_args)]
9252 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9253 }
9254 if self.sub_level_id != 0 {
9255 #[allow(clippy::needless_borrow)]
9256 #[allow(clippy::needless_borrows_for_generic_args)]
9257 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
9258 }
9259 if self.uncompressed_file_size != 0 {
9260 #[allow(clippy::needless_borrow)]
9261 #[allow(clippy::needless_borrows_for_generic_args)]
9262 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
9263 }
9264 if self.vnode_partition_count != 0 {
9265 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
9266 }
9267 struct_ser.end()
9268 }
9269}
9270impl<'de> serde::Deserialize<'de> for Level {
9271 #[allow(deprecated)]
9272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9273 where
9274 D: serde::Deserializer<'de>,
9275 {
9276 const FIELDS: &[&str] = &[
9277 "level_idx",
9278 "levelIdx",
9279 "level_type",
9280 "levelType",
9281 "table_infos",
9282 "tableInfos",
9283 "total_file_size",
9284 "totalFileSize",
9285 "sub_level_id",
9286 "subLevelId",
9287 "uncompressed_file_size",
9288 "uncompressedFileSize",
9289 "vnode_partition_count",
9290 "vnodePartitionCount",
9291 ];
9292
9293 #[allow(clippy::enum_variant_names)]
9294 enum GeneratedField {
9295 LevelIdx,
9296 LevelType,
9297 TableInfos,
9298 TotalFileSize,
9299 SubLevelId,
9300 UncompressedFileSize,
9301 VnodePartitionCount,
9302 }
9303 impl<'de> serde::Deserialize<'de> for GeneratedField {
9304 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9305 where
9306 D: serde::Deserializer<'de>,
9307 {
9308 struct GeneratedVisitor;
9309
9310 impl serde::de::Visitor<'_> for GeneratedVisitor {
9311 type Value = GeneratedField;
9312
9313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9314 write!(formatter, "expected one of: {:?}", &FIELDS)
9315 }
9316
9317 #[allow(unused_variables)]
9318 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9319 where
9320 E: serde::de::Error,
9321 {
9322 match value {
9323 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
9324 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
9325 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
9326 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9327 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
9328 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
9329 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
9330 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9331 }
9332 }
9333 }
9334 deserializer.deserialize_identifier(GeneratedVisitor)
9335 }
9336 }
9337 struct GeneratedVisitor;
9338 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9339 type Value = Level;
9340
9341 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9342 formatter.write_str("struct hummock.Level")
9343 }
9344
9345 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
9346 where
9347 V: serde::de::MapAccess<'de>,
9348 {
9349 let mut level_idx__ = None;
9350 let mut level_type__ = None;
9351 let mut table_infos__ = None;
9352 let mut total_file_size__ = None;
9353 let mut sub_level_id__ = None;
9354 let mut uncompressed_file_size__ = None;
9355 let mut vnode_partition_count__ = None;
9356 while let Some(k) = map_.next_key()? {
9357 match k {
9358 GeneratedField::LevelIdx => {
9359 if level_idx__.is_some() {
9360 return Err(serde::de::Error::duplicate_field("levelIdx"));
9361 }
9362 level_idx__ =
9363 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9364 ;
9365 }
9366 GeneratedField::LevelType => {
9367 if level_type__.is_some() {
9368 return Err(serde::de::Error::duplicate_field("levelType"));
9369 }
9370 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
9371 }
9372 GeneratedField::TableInfos => {
9373 if table_infos__.is_some() {
9374 return Err(serde::de::Error::duplicate_field("tableInfos"));
9375 }
9376 table_infos__ = Some(map_.next_value()?);
9377 }
9378 GeneratedField::TotalFileSize => {
9379 if total_file_size__.is_some() {
9380 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9381 }
9382 total_file_size__ =
9383 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9384 ;
9385 }
9386 GeneratedField::SubLevelId => {
9387 if sub_level_id__.is_some() {
9388 return Err(serde::de::Error::duplicate_field("subLevelId"));
9389 }
9390 sub_level_id__ =
9391 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9392 ;
9393 }
9394 GeneratedField::UncompressedFileSize => {
9395 if uncompressed_file_size__.is_some() {
9396 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
9397 }
9398 uncompressed_file_size__ =
9399 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9400 ;
9401 }
9402 GeneratedField::VnodePartitionCount => {
9403 if vnode_partition_count__.is_some() {
9404 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
9405 }
9406 vnode_partition_count__ =
9407 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9408 ;
9409 }
9410 }
9411 }
9412 Ok(Level {
9413 level_idx: level_idx__.unwrap_or_default(),
9414 level_type: level_type__.unwrap_or_default(),
9415 table_infos: table_infos__.unwrap_or_default(),
9416 total_file_size: total_file_size__.unwrap_or_default(),
9417 sub_level_id: sub_level_id__.unwrap_or_default(),
9418 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
9419 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
9420 })
9421 }
9422 }
9423 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
9424 }
9425}
9426impl serde::Serialize for LevelHandler {
9427 #[allow(deprecated)]
9428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9429 where
9430 S: serde::Serializer,
9431 {
9432 use serde::ser::SerializeStruct;
9433 let mut len = 0;
9434 if self.level != 0 {
9435 len += 1;
9436 }
9437 if !self.tasks.is_empty() {
9438 len += 1;
9439 }
9440 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
9441 if self.level != 0 {
9442 struct_ser.serialize_field("level", &self.level)?;
9443 }
9444 if !self.tasks.is_empty() {
9445 struct_ser.serialize_field("tasks", &self.tasks)?;
9446 }
9447 struct_ser.end()
9448 }
9449}
9450impl<'de> serde::Deserialize<'de> for LevelHandler {
9451 #[allow(deprecated)]
9452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9453 where
9454 D: serde::Deserializer<'de>,
9455 {
9456 const FIELDS: &[&str] = &[
9457 "level",
9458 "tasks",
9459 ];
9460
9461 #[allow(clippy::enum_variant_names)]
9462 enum GeneratedField {
9463 Level,
9464 Tasks,
9465 }
9466 impl<'de> serde::Deserialize<'de> for GeneratedField {
9467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9468 where
9469 D: serde::Deserializer<'de>,
9470 {
9471 struct GeneratedVisitor;
9472
9473 impl serde::de::Visitor<'_> for GeneratedVisitor {
9474 type Value = GeneratedField;
9475
9476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9477 write!(formatter, "expected one of: {:?}", &FIELDS)
9478 }
9479
9480 #[allow(unused_variables)]
9481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9482 where
9483 E: serde::de::Error,
9484 {
9485 match value {
9486 "level" => Ok(GeneratedField::Level),
9487 "tasks" => Ok(GeneratedField::Tasks),
9488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9489 }
9490 }
9491 }
9492 deserializer.deserialize_identifier(GeneratedVisitor)
9493 }
9494 }
9495 struct GeneratedVisitor;
9496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9497 type Value = LevelHandler;
9498
9499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9500 formatter.write_str("struct hummock.LevelHandler")
9501 }
9502
9503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
9504 where
9505 V: serde::de::MapAccess<'de>,
9506 {
9507 let mut level__ = None;
9508 let mut tasks__ = None;
9509 while let Some(k) = map_.next_key()? {
9510 match k {
9511 GeneratedField::Level => {
9512 if level__.is_some() {
9513 return Err(serde::de::Error::duplicate_field("level"));
9514 }
9515 level__ =
9516 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9517 ;
9518 }
9519 GeneratedField::Tasks => {
9520 if tasks__.is_some() {
9521 return Err(serde::de::Error::duplicate_field("tasks"));
9522 }
9523 tasks__ = Some(map_.next_value()?);
9524 }
9525 }
9526 }
9527 Ok(LevelHandler {
9528 level: level__.unwrap_or_default(),
9529 tasks: tasks__.unwrap_or_default(),
9530 })
9531 }
9532 }
9533 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
9534 }
9535}
9536impl serde::Serialize for level_handler::RunningCompactTask {
9537 #[allow(deprecated)]
9538 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9539 where
9540 S: serde::Serializer,
9541 {
9542 use serde::ser::SerializeStruct;
9543 let mut len = 0;
9544 if self.task_id != 0 {
9545 len += 1;
9546 }
9547 if !self.ssts.is_empty() {
9548 len += 1;
9549 }
9550 if self.total_file_size != 0 {
9551 len += 1;
9552 }
9553 if self.target_level != 0 {
9554 len += 1;
9555 }
9556 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
9557 if self.task_id != 0 {
9558 #[allow(clippy::needless_borrow)]
9559 #[allow(clippy::needless_borrows_for_generic_args)]
9560 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
9561 }
9562 if !self.ssts.is_empty() {
9563 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
9564 }
9565 if self.total_file_size != 0 {
9566 #[allow(clippy::needless_borrow)]
9567 #[allow(clippy::needless_borrows_for_generic_args)]
9568 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9569 }
9570 if self.target_level != 0 {
9571 struct_ser.serialize_field("targetLevel", &self.target_level)?;
9572 }
9573 struct_ser.end()
9574 }
9575}
9576impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
9577 #[allow(deprecated)]
9578 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9579 where
9580 D: serde::Deserializer<'de>,
9581 {
9582 const FIELDS: &[&str] = &[
9583 "task_id",
9584 "taskId",
9585 "ssts",
9586 "total_file_size",
9587 "totalFileSize",
9588 "target_level",
9589 "targetLevel",
9590 ];
9591
9592 #[allow(clippy::enum_variant_names)]
9593 enum GeneratedField {
9594 TaskId,
9595 Ssts,
9596 TotalFileSize,
9597 TargetLevel,
9598 }
9599 impl<'de> serde::Deserialize<'de> for GeneratedField {
9600 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9601 where
9602 D: serde::Deserializer<'de>,
9603 {
9604 struct GeneratedVisitor;
9605
9606 impl serde::de::Visitor<'_> for GeneratedVisitor {
9607 type Value = GeneratedField;
9608
9609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9610 write!(formatter, "expected one of: {:?}", &FIELDS)
9611 }
9612
9613 #[allow(unused_variables)]
9614 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9615 where
9616 E: serde::de::Error,
9617 {
9618 match value {
9619 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
9620 "ssts" => Ok(GeneratedField::Ssts),
9621 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9622 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
9623 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9624 }
9625 }
9626 }
9627 deserializer.deserialize_identifier(GeneratedVisitor)
9628 }
9629 }
9630 struct GeneratedVisitor;
9631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9632 type Value = level_handler::RunningCompactTask;
9633
9634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9635 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
9636 }
9637
9638 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
9639 where
9640 V: serde::de::MapAccess<'de>,
9641 {
9642 let mut task_id__ = None;
9643 let mut ssts__ = None;
9644 let mut total_file_size__ = None;
9645 let mut target_level__ = None;
9646 while let Some(k) = map_.next_key()? {
9647 match k {
9648 GeneratedField::TaskId => {
9649 if task_id__.is_some() {
9650 return Err(serde::de::Error::duplicate_field("taskId"));
9651 }
9652 task_id__ =
9653 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9654 ;
9655 }
9656 GeneratedField::Ssts => {
9657 if ssts__.is_some() {
9658 return Err(serde::de::Error::duplicate_field("ssts"));
9659 }
9660 ssts__ =
9661 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9662 .into_iter().map(|x| x.0).collect())
9663 ;
9664 }
9665 GeneratedField::TotalFileSize => {
9666 if total_file_size__.is_some() {
9667 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9668 }
9669 total_file_size__ =
9670 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9671 ;
9672 }
9673 GeneratedField::TargetLevel => {
9674 if target_level__.is_some() {
9675 return Err(serde::de::Error::duplicate_field("targetLevel"));
9676 }
9677 target_level__ =
9678 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9679 ;
9680 }
9681 }
9682 }
9683 Ok(level_handler::RunningCompactTask {
9684 task_id: task_id__.unwrap_or_default(),
9685 ssts: ssts__.unwrap_or_default(),
9686 total_file_size: total_file_size__.unwrap_or_default(),
9687 target_level: target_level__.unwrap_or_default(),
9688 })
9689 }
9690 }
9691 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
9692 }
9693}
9694impl serde::Serialize for LevelType {
9695 #[allow(deprecated)]
9696 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9697 where
9698 S: serde::Serializer,
9699 {
9700 let variant = match self {
9701 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
9702 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
9703 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
9704 };
9705 serializer.serialize_str(variant)
9706 }
9707}
9708impl<'de> serde::Deserialize<'de> for LevelType {
9709 #[allow(deprecated)]
9710 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9711 where
9712 D: serde::Deserializer<'de>,
9713 {
9714 const FIELDS: &[&str] = &[
9715 "LEVEL_TYPE_UNSPECIFIED",
9716 "LEVEL_TYPE_NONOVERLAPPING",
9717 "LEVEL_TYPE_OVERLAPPING",
9718 ];
9719
9720 struct GeneratedVisitor;
9721
9722 impl serde::de::Visitor<'_> for GeneratedVisitor {
9723 type Value = LevelType;
9724
9725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9726 write!(formatter, "expected one of: {:?}", &FIELDS)
9727 }
9728
9729 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9730 where
9731 E: serde::de::Error,
9732 {
9733 i32::try_from(v)
9734 .ok()
9735 .and_then(|x| x.try_into().ok())
9736 .ok_or_else(|| {
9737 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9738 })
9739 }
9740
9741 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9742 where
9743 E: serde::de::Error,
9744 {
9745 i32::try_from(v)
9746 .ok()
9747 .and_then(|x| x.try_into().ok())
9748 .ok_or_else(|| {
9749 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9750 })
9751 }
9752
9753 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9754 where
9755 E: serde::de::Error,
9756 {
9757 match value {
9758 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
9759 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
9760 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
9761 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9762 }
9763 }
9764 }
9765 deserializer.deserialize_any(GeneratedVisitor)
9766 }
9767}
9768impl serde::Serialize for ListActiveWriteLimitRequest {
9769 #[allow(deprecated)]
9770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9771 where
9772 S: serde::Serializer,
9773 {
9774 use serde::ser::SerializeStruct;
9775 let len = 0;
9776 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
9777 struct_ser.end()
9778 }
9779}
9780impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
9781 #[allow(deprecated)]
9782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9783 where
9784 D: serde::Deserializer<'de>,
9785 {
9786 const FIELDS: &[&str] = &[
9787 ];
9788
9789 #[allow(clippy::enum_variant_names)]
9790 enum GeneratedField {
9791 }
9792 impl<'de> serde::Deserialize<'de> for GeneratedField {
9793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9794 where
9795 D: serde::Deserializer<'de>,
9796 {
9797 struct GeneratedVisitor;
9798
9799 impl serde::de::Visitor<'_> for GeneratedVisitor {
9800 type Value = GeneratedField;
9801
9802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9803 write!(formatter, "expected one of: {:?}", &FIELDS)
9804 }
9805
9806 #[allow(unused_variables)]
9807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9808 where
9809 E: serde::de::Error,
9810 {
9811 Err(serde::de::Error::unknown_field(value, FIELDS))
9812 }
9813 }
9814 deserializer.deserialize_identifier(GeneratedVisitor)
9815 }
9816 }
9817 struct GeneratedVisitor;
9818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9819 type Value = ListActiveWriteLimitRequest;
9820
9821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9822 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
9823 }
9824
9825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
9826 where
9827 V: serde::de::MapAccess<'de>,
9828 {
9829 while map_.next_key::<GeneratedField>()?.is_some() {
9830 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9831 }
9832 Ok(ListActiveWriteLimitRequest {
9833 })
9834 }
9835 }
9836 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
9837 }
9838}
9839impl serde::Serialize for ListActiveWriteLimitResponse {
9840 #[allow(deprecated)]
9841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9842 where
9843 S: serde::Serializer,
9844 {
9845 use serde::ser::SerializeStruct;
9846 let mut len = 0;
9847 if !self.write_limits.is_empty() {
9848 len += 1;
9849 }
9850 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
9851 if !self.write_limits.is_empty() {
9852 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
9853 }
9854 struct_ser.end()
9855 }
9856}
9857impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
9858 #[allow(deprecated)]
9859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9860 where
9861 D: serde::Deserializer<'de>,
9862 {
9863 const FIELDS: &[&str] = &[
9864 "write_limits",
9865 "writeLimits",
9866 ];
9867
9868 #[allow(clippy::enum_variant_names)]
9869 enum GeneratedField {
9870 WriteLimits,
9871 }
9872 impl<'de> serde::Deserialize<'de> for GeneratedField {
9873 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9874 where
9875 D: serde::Deserializer<'de>,
9876 {
9877 struct GeneratedVisitor;
9878
9879 impl serde::de::Visitor<'_> for GeneratedVisitor {
9880 type Value = GeneratedField;
9881
9882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9883 write!(formatter, "expected one of: {:?}", &FIELDS)
9884 }
9885
9886 #[allow(unused_variables)]
9887 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9888 where
9889 E: serde::de::Error,
9890 {
9891 match value {
9892 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
9893 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9894 }
9895 }
9896 }
9897 deserializer.deserialize_identifier(GeneratedVisitor)
9898 }
9899 }
9900 struct GeneratedVisitor;
9901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9902 type Value = ListActiveWriteLimitResponse;
9903
9904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9905 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
9906 }
9907
9908 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
9909 where
9910 V: serde::de::MapAccess<'de>,
9911 {
9912 let mut write_limits__ = None;
9913 while let Some(k) = map_.next_key()? {
9914 match k {
9915 GeneratedField::WriteLimits => {
9916 if write_limits__.is_some() {
9917 return Err(serde::de::Error::duplicate_field("writeLimits"));
9918 }
9919 write_limits__ = Some(
9920 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
9921 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9922 );
9923 }
9924 }
9925 }
9926 Ok(ListActiveWriteLimitResponse {
9927 write_limits: write_limits__.unwrap_or_default(),
9928 })
9929 }
9930 }
9931 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
9932 }
9933}
9934impl serde::Serialize for ListBranchedObjectRequest {
9935 #[allow(deprecated)]
9936 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9937 where
9938 S: serde::Serializer,
9939 {
9940 use serde::ser::SerializeStruct;
9941 let len = 0;
9942 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
9943 struct_ser.end()
9944 }
9945}
9946impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
9947 #[allow(deprecated)]
9948 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9949 where
9950 D: serde::Deserializer<'de>,
9951 {
9952 const FIELDS: &[&str] = &[
9953 ];
9954
9955 #[allow(clippy::enum_variant_names)]
9956 enum GeneratedField {
9957 }
9958 impl<'de> serde::Deserialize<'de> for GeneratedField {
9959 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9960 where
9961 D: serde::Deserializer<'de>,
9962 {
9963 struct GeneratedVisitor;
9964
9965 impl serde::de::Visitor<'_> for GeneratedVisitor {
9966 type Value = GeneratedField;
9967
9968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9969 write!(formatter, "expected one of: {:?}", &FIELDS)
9970 }
9971
9972 #[allow(unused_variables)]
9973 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9974 where
9975 E: serde::de::Error,
9976 {
9977 Err(serde::de::Error::unknown_field(value, FIELDS))
9978 }
9979 }
9980 deserializer.deserialize_identifier(GeneratedVisitor)
9981 }
9982 }
9983 struct GeneratedVisitor;
9984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9985 type Value = ListBranchedObjectRequest;
9986
9987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9988 formatter.write_str("struct hummock.ListBranchedObjectRequest")
9989 }
9990
9991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
9992 where
9993 V: serde::de::MapAccess<'de>,
9994 {
9995 while map_.next_key::<GeneratedField>()?.is_some() {
9996 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9997 }
9998 Ok(ListBranchedObjectRequest {
9999 })
10000 }
10001 }
10002 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
10003 }
10004}
10005impl serde::Serialize for ListBranchedObjectResponse {
10006 #[allow(deprecated)]
10007 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10008 where
10009 S: serde::Serializer,
10010 {
10011 use serde::ser::SerializeStruct;
10012 let mut len = 0;
10013 if !self.branched_objects.is_empty() {
10014 len += 1;
10015 }
10016 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
10017 if !self.branched_objects.is_empty() {
10018 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
10019 }
10020 struct_ser.end()
10021 }
10022}
10023impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
10024 #[allow(deprecated)]
10025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10026 where
10027 D: serde::Deserializer<'de>,
10028 {
10029 const FIELDS: &[&str] = &[
10030 "branched_objects",
10031 "branchedObjects",
10032 ];
10033
10034 #[allow(clippy::enum_variant_names)]
10035 enum GeneratedField {
10036 BranchedObjects,
10037 }
10038 impl<'de> serde::Deserialize<'de> for GeneratedField {
10039 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10040 where
10041 D: serde::Deserializer<'de>,
10042 {
10043 struct GeneratedVisitor;
10044
10045 impl serde::de::Visitor<'_> for GeneratedVisitor {
10046 type Value = GeneratedField;
10047
10048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10049 write!(formatter, "expected one of: {:?}", &FIELDS)
10050 }
10051
10052 #[allow(unused_variables)]
10053 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10054 where
10055 E: serde::de::Error,
10056 {
10057 match value {
10058 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
10059 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10060 }
10061 }
10062 }
10063 deserializer.deserialize_identifier(GeneratedVisitor)
10064 }
10065 }
10066 struct GeneratedVisitor;
10067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10068 type Value = ListBranchedObjectResponse;
10069
10070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10071 formatter.write_str("struct hummock.ListBranchedObjectResponse")
10072 }
10073
10074 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
10075 where
10076 V: serde::de::MapAccess<'de>,
10077 {
10078 let mut branched_objects__ = None;
10079 while let Some(k) = map_.next_key()? {
10080 match k {
10081 GeneratedField::BranchedObjects => {
10082 if branched_objects__.is_some() {
10083 return Err(serde::de::Error::duplicate_field("branchedObjects"));
10084 }
10085 branched_objects__ = Some(map_.next_value()?);
10086 }
10087 }
10088 }
10089 Ok(ListBranchedObjectResponse {
10090 branched_objects: branched_objects__.unwrap_or_default(),
10091 })
10092 }
10093 }
10094 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
10095 }
10096}
10097impl serde::Serialize for ListCompactTaskAssignmentRequest {
10098 #[allow(deprecated)]
10099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10100 where
10101 S: serde::Serializer,
10102 {
10103 use serde::ser::SerializeStruct;
10104 let len = 0;
10105 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
10106 struct_ser.end()
10107 }
10108}
10109impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
10110 #[allow(deprecated)]
10111 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10112 where
10113 D: serde::Deserializer<'de>,
10114 {
10115 const FIELDS: &[&str] = &[
10116 ];
10117
10118 #[allow(clippy::enum_variant_names)]
10119 enum GeneratedField {
10120 }
10121 impl<'de> serde::Deserialize<'de> for GeneratedField {
10122 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10123 where
10124 D: serde::Deserializer<'de>,
10125 {
10126 struct GeneratedVisitor;
10127
10128 impl serde::de::Visitor<'_> for GeneratedVisitor {
10129 type Value = GeneratedField;
10130
10131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10132 write!(formatter, "expected one of: {:?}", &FIELDS)
10133 }
10134
10135 #[allow(unused_variables)]
10136 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10137 where
10138 E: serde::de::Error,
10139 {
10140 Err(serde::de::Error::unknown_field(value, FIELDS))
10141 }
10142 }
10143 deserializer.deserialize_identifier(GeneratedVisitor)
10144 }
10145 }
10146 struct GeneratedVisitor;
10147 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10148 type Value = ListCompactTaskAssignmentRequest;
10149
10150 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10151 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
10152 }
10153
10154 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
10155 where
10156 V: serde::de::MapAccess<'de>,
10157 {
10158 while map_.next_key::<GeneratedField>()?.is_some() {
10159 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10160 }
10161 Ok(ListCompactTaskAssignmentRequest {
10162 })
10163 }
10164 }
10165 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
10166 }
10167}
10168impl serde::Serialize for ListCompactTaskAssignmentResponse {
10169 #[allow(deprecated)]
10170 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10171 where
10172 S: serde::Serializer,
10173 {
10174 use serde::ser::SerializeStruct;
10175 let mut len = 0;
10176 if !self.task_assignment.is_empty() {
10177 len += 1;
10178 }
10179 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
10180 if !self.task_assignment.is_empty() {
10181 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
10182 }
10183 struct_ser.end()
10184 }
10185}
10186impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
10187 #[allow(deprecated)]
10188 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10189 where
10190 D: serde::Deserializer<'de>,
10191 {
10192 const FIELDS: &[&str] = &[
10193 "task_assignment",
10194 "taskAssignment",
10195 ];
10196
10197 #[allow(clippy::enum_variant_names)]
10198 enum GeneratedField {
10199 TaskAssignment,
10200 }
10201 impl<'de> serde::Deserialize<'de> for GeneratedField {
10202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10203 where
10204 D: serde::Deserializer<'de>,
10205 {
10206 struct GeneratedVisitor;
10207
10208 impl serde::de::Visitor<'_> for GeneratedVisitor {
10209 type Value = GeneratedField;
10210
10211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10212 write!(formatter, "expected one of: {:?}", &FIELDS)
10213 }
10214
10215 #[allow(unused_variables)]
10216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10217 where
10218 E: serde::de::Error,
10219 {
10220 match value {
10221 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
10222 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10223 }
10224 }
10225 }
10226 deserializer.deserialize_identifier(GeneratedVisitor)
10227 }
10228 }
10229 struct GeneratedVisitor;
10230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10231 type Value = ListCompactTaskAssignmentResponse;
10232
10233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10234 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
10235 }
10236
10237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
10238 where
10239 V: serde::de::MapAccess<'de>,
10240 {
10241 let mut task_assignment__ = None;
10242 while let Some(k) = map_.next_key()? {
10243 match k {
10244 GeneratedField::TaskAssignment => {
10245 if task_assignment__.is_some() {
10246 return Err(serde::de::Error::duplicate_field("taskAssignment"));
10247 }
10248 task_assignment__ = Some(map_.next_value()?);
10249 }
10250 }
10251 }
10252 Ok(ListCompactTaskAssignmentResponse {
10253 task_assignment: task_assignment__.unwrap_or_default(),
10254 })
10255 }
10256 }
10257 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
10258 }
10259}
10260impl serde::Serialize for ListCompactTaskProgressRequest {
10261 #[allow(deprecated)]
10262 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10263 where
10264 S: serde::Serializer,
10265 {
10266 use serde::ser::SerializeStruct;
10267 let len = 0;
10268 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
10269 struct_ser.end()
10270 }
10271}
10272impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
10273 #[allow(deprecated)]
10274 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10275 where
10276 D: serde::Deserializer<'de>,
10277 {
10278 const FIELDS: &[&str] = &[
10279 ];
10280
10281 #[allow(clippy::enum_variant_names)]
10282 enum GeneratedField {
10283 }
10284 impl<'de> serde::Deserialize<'de> for GeneratedField {
10285 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10286 where
10287 D: serde::Deserializer<'de>,
10288 {
10289 struct GeneratedVisitor;
10290
10291 impl serde::de::Visitor<'_> for GeneratedVisitor {
10292 type Value = GeneratedField;
10293
10294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10295 write!(formatter, "expected one of: {:?}", &FIELDS)
10296 }
10297
10298 #[allow(unused_variables)]
10299 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10300 where
10301 E: serde::de::Error,
10302 {
10303 Err(serde::de::Error::unknown_field(value, FIELDS))
10304 }
10305 }
10306 deserializer.deserialize_identifier(GeneratedVisitor)
10307 }
10308 }
10309 struct GeneratedVisitor;
10310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10311 type Value = ListCompactTaskProgressRequest;
10312
10313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10314 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
10315 }
10316
10317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
10318 where
10319 V: serde::de::MapAccess<'de>,
10320 {
10321 while map_.next_key::<GeneratedField>()?.is_some() {
10322 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10323 }
10324 Ok(ListCompactTaskProgressRequest {
10325 })
10326 }
10327 }
10328 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
10329 }
10330}
10331impl serde::Serialize for ListCompactTaskProgressResponse {
10332 #[allow(deprecated)]
10333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10334 where
10335 S: serde::Serializer,
10336 {
10337 use serde::ser::SerializeStruct;
10338 let mut len = 0;
10339 if !self.task_progress.is_empty() {
10340 len += 1;
10341 }
10342 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
10343 if !self.task_progress.is_empty() {
10344 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
10345 }
10346 struct_ser.end()
10347 }
10348}
10349impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
10350 #[allow(deprecated)]
10351 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10352 where
10353 D: serde::Deserializer<'de>,
10354 {
10355 const FIELDS: &[&str] = &[
10356 "task_progress",
10357 "taskProgress",
10358 ];
10359
10360 #[allow(clippy::enum_variant_names)]
10361 enum GeneratedField {
10362 TaskProgress,
10363 }
10364 impl<'de> serde::Deserialize<'de> for GeneratedField {
10365 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10366 where
10367 D: serde::Deserializer<'de>,
10368 {
10369 struct GeneratedVisitor;
10370
10371 impl serde::de::Visitor<'_> for GeneratedVisitor {
10372 type Value = GeneratedField;
10373
10374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10375 write!(formatter, "expected one of: {:?}", &FIELDS)
10376 }
10377
10378 #[allow(unused_variables)]
10379 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10380 where
10381 E: serde::de::Error,
10382 {
10383 match value {
10384 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
10385 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10386 }
10387 }
10388 }
10389 deserializer.deserialize_identifier(GeneratedVisitor)
10390 }
10391 }
10392 struct GeneratedVisitor;
10393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10394 type Value = ListCompactTaskProgressResponse;
10395
10396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10397 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
10398 }
10399
10400 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
10401 where
10402 V: serde::de::MapAccess<'de>,
10403 {
10404 let mut task_progress__ = None;
10405 while let Some(k) = map_.next_key()? {
10406 match k {
10407 GeneratedField::TaskProgress => {
10408 if task_progress__.is_some() {
10409 return Err(serde::de::Error::duplicate_field("taskProgress"));
10410 }
10411 task_progress__ = Some(map_.next_value()?);
10412 }
10413 }
10414 }
10415 Ok(ListCompactTaskProgressResponse {
10416 task_progress: task_progress__.unwrap_or_default(),
10417 })
10418 }
10419 }
10420 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
10421 }
10422}
10423impl serde::Serialize for ListHummockMetaConfigRequest {
10424 #[allow(deprecated)]
10425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10426 where
10427 S: serde::Serializer,
10428 {
10429 use serde::ser::SerializeStruct;
10430 let len = 0;
10431 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
10432 struct_ser.end()
10433 }
10434}
10435impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
10436 #[allow(deprecated)]
10437 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10438 where
10439 D: serde::Deserializer<'de>,
10440 {
10441 const FIELDS: &[&str] = &[
10442 ];
10443
10444 #[allow(clippy::enum_variant_names)]
10445 enum GeneratedField {
10446 }
10447 impl<'de> serde::Deserialize<'de> for GeneratedField {
10448 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10449 where
10450 D: serde::Deserializer<'de>,
10451 {
10452 struct GeneratedVisitor;
10453
10454 impl serde::de::Visitor<'_> for GeneratedVisitor {
10455 type Value = GeneratedField;
10456
10457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10458 write!(formatter, "expected one of: {:?}", &FIELDS)
10459 }
10460
10461 #[allow(unused_variables)]
10462 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10463 where
10464 E: serde::de::Error,
10465 {
10466 Err(serde::de::Error::unknown_field(value, FIELDS))
10467 }
10468 }
10469 deserializer.deserialize_identifier(GeneratedVisitor)
10470 }
10471 }
10472 struct GeneratedVisitor;
10473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10474 type Value = ListHummockMetaConfigRequest;
10475
10476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10477 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
10478 }
10479
10480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
10481 where
10482 V: serde::de::MapAccess<'de>,
10483 {
10484 while map_.next_key::<GeneratedField>()?.is_some() {
10485 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10486 }
10487 Ok(ListHummockMetaConfigRequest {
10488 })
10489 }
10490 }
10491 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
10492 }
10493}
10494impl serde::Serialize for ListHummockMetaConfigResponse {
10495 #[allow(deprecated)]
10496 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10497 where
10498 S: serde::Serializer,
10499 {
10500 use serde::ser::SerializeStruct;
10501 let mut len = 0;
10502 if !self.configs.is_empty() {
10503 len += 1;
10504 }
10505 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
10506 if !self.configs.is_empty() {
10507 struct_ser.serialize_field("configs", &self.configs)?;
10508 }
10509 struct_ser.end()
10510 }
10511}
10512impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
10513 #[allow(deprecated)]
10514 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10515 where
10516 D: serde::Deserializer<'de>,
10517 {
10518 const FIELDS: &[&str] = &[
10519 "configs",
10520 ];
10521
10522 #[allow(clippy::enum_variant_names)]
10523 enum GeneratedField {
10524 Configs,
10525 }
10526 impl<'de> serde::Deserialize<'de> for GeneratedField {
10527 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10528 where
10529 D: serde::Deserializer<'de>,
10530 {
10531 struct GeneratedVisitor;
10532
10533 impl serde::de::Visitor<'_> for GeneratedVisitor {
10534 type Value = GeneratedField;
10535
10536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10537 write!(formatter, "expected one of: {:?}", &FIELDS)
10538 }
10539
10540 #[allow(unused_variables)]
10541 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10542 where
10543 E: serde::de::Error,
10544 {
10545 match value {
10546 "configs" => Ok(GeneratedField::Configs),
10547 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10548 }
10549 }
10550 }
10551 deserializer.deserialize_identifier(GeneratedVisitor)
10552 }
10553 }
10554 struct GeneratedVisitor;
10555 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10556 type Value = ListHummockMetaConfigResponse;
10557
10558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10559 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
10560 }
10561
10562 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
10563 where
10564 V: serde::de::MapAccess<'de>,
10565 {
10566 let mut configs__ = None;
10567 while let Some(k) = map_.next_key()? {
10568 match k {
10569 GeneratedField::Configs => {
10570 if configs__.is_some() {
10571 return Err(serde::de::Error::duplicate_field("configs"));
10572 }
10573 configs__ = Some(
10574 map_.next_value::<std::collections::HashMap<_, _>>()?
10575 );
10576 }
10577 }
10578 }
10579 Ok(ListHummockMetaConfigResponse {
10580 configs: configs__.unwrap_or_default(),
10581 })
10582 }
10583 }
10584 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
10585 }
10586}
10587impl serde::Serialize for ListVersionDeltasRequest {
10588 #[allow(deprecated)]
10589 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10590 where
10591 S: serde::Serializer,
10592 {
10593 use serde::ser::SerializeStruct;
10594 let mut len = 0;
10595 if self.start_id != 0 {
10596 len += 1;
10597 }
10598 if self.num_limit != 0 {
10599 len += 1;
10600 }
10601 if self.committed_epoch_limit != 0 {
10602 len += 1;
10603 }
10604 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
10605 if self.start_id != 0 {
10606 #[allow(clippy::needless_borrow)]
10607 #[allow(clippy::needless_borrows_for_generic_args)]
10608 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
10609 }
10610 if self.num_limit != 0 {
10611 struct_ser.serialize_field("numLimit", &self.num_limit)?;
10612 }
10613 if self.committed_epoch_limit != 0 {
10614 #[allow(clippy::needless_borrow)]
10615 #[allow(clippy::needless_borrows_for_generic_args)]
10616 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
10617 }
10618 struct_ser.end()
10619 }
10620}
10621impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
10622 #[allow(deprecated)]
10623 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10624 where
10625 D: serde::Deserializer<'de>,
10626 {
10627 const FIELDS: &[&str] = &[
10628 "start_id",
10629 "startId",
10630 "num_limit",
10631 "numLimit",
10632 "committed_epoch_limit",
10633 "committedEpochLimit",
10634 ];
10635
10636 #[allow(clippy::enum_variant_names)]
10637 enum GeneratedField {
10638 StartId,
10639 NumLimit,
10640 CommittedEpochLimit,
10641 }
10642 impl<'de> serde::Deserialize<'de> for GeneratedField {
10643 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10644 where
10645 D: serde::Deserializer<'de>,
10646 {
10647 struct GeneratedVisitor;
10648
10649 impl serde::de::Visitor<'_> for GeneratedVisitor {
10650 type Value = GeneratedField;
10651
10652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10653 write!(formatter, "expected one of: {:?}", &FIELDS)
10654 }
10655
10656 #[allow(unused_variables)]
10657 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10658 where
10659 E: serde::de::Error,
10660 {
10661 match value {
10662 "startId" | "start_id" => Ok(GeneratedField::StartId),
10663 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
10664 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
10665 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10666 }
10667 }
10668 }
10669 deserializer.deserialize_identifier(GeneratedVisitor)
10670 }
10671 }
10672 struct GeneratedVisitor;
10673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10674 type Value = ListVersionDeltasRequest;
10675
10676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10677 formatter.write_str("struct hummock.ListVersionDeltasRequest")
10678 }
10679
10680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
10681 where
10682 V: serde::de::MapAccess<'de>,
10683 {
10684 let mut start_id__ = None;
10685 let mut num_limit__ = None;
10686 let mut committed_epoch_limit__ = None;
10687 while let Some(k) = map_.next_key()? {
10688 match k {
10689 GeneratedField::StartId => {
10690 if start_id__.is_some() {
10691 return Err(serde::de::Error::duplicate_field("startId"));
10692 }
10693 start_id__ =
10694 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10695 ;
10696 }
10697 GeneratedField::NumLimit => {
10698 if num_limit__.is_some() {
10699 return Err(serde::de::Error::duplicate_field("numLimit"));
10700 }
10701 num_limit__ =
10702 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10703 ;
10704 }
10705 GeneratedField::CommittedEpochLimit => {
10706 if committed_epoch_limit__.is_some() {
10707 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
10708 }
10709 committed_epoch_limit__ =
10710 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10711 ;
10712 }
10713 }
10714 }
10715 Ok(ListVersionDeltasRequest {
10716 start_id: start_id__.unwrap_or_default(),
10717 num_limit: num_limit__.unwrap_or_default(),
10718 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
10719 })
10720 }
10721 }
10722 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
10723 }
10724}
10725impl serde::Serialize for ListVersionDeltasResponse {
10726 #[allow(deprecated)]
10727 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10728 where
10729 S: serde::Serializer,
10730 {
10731 use serde::ser::SerializeStruct;
10732 let mut len = 0;
10733 if self.version_deltas.is_some() {
10734 len += 1;
10735 }
10736 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
10737 if let Some(v) = self.version_deltas.as_ref() {
10738 struct_ser.serialize_field("versionDeltas", v)?;
10739 }
10740 struct_ser.end()
10741 }
10742}
10743impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
10744 #[allow(deprecated)]
10745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10746 where
10747 D: serde::Deserializer<'de>,
10748 {
10749 const FIELDS: &[&str] = &[
10750 "version_deltas",
10751 "versionDeltas",
10752 ];
10753
10754 #[allow(clippy::enum_variant_names)]
10755 enum GeneratedField {
10756 VersionDeltas,
10757 }
10758 impl<'de> serde::Deserialize<'de> for GeneratedField {
10759 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10760 where
10761 D: serde::Deserializer<'de>,
10762 {
10763 struct GeneratedVisitor;
10764
10765 impl serde::de::Visitor<'_> for GeneratedVisitor {
10766 type Value = GeneratedField;
10767
10768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10769 write!(formatter, "expected one of: {:?}", &FIELDS)
10770 }
10771
10772 #[allow(unused_variables)]
10773 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10774 where
10775 E: serde::de::Error,
10776 {
10777 match value {
10778 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
10779 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10780 }
10781 }
10782 }
10783 deserializer.deserialize_identifier(GeneratedVisitor)
10784 }
10785 }
10786 struct GeneratedVisitor;
10787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10788 type Value = ListVersionDeltasResponse;
10789
10790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10791 formatter.write_str("struct hummock.ListVersionDeltasResponse")
10792 }
10793
10794 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
10795 where
10796 V: serde::de::MapAccess<'de>,
10797 {
10798 let mut version_deltas__ = None;
10799 while let Some(k) = map_.next_key()? {
10800 match k {
10801 GeneratedField::VersionDeltas => {
10802 if version_deltas__.is_some() {
10803 return Err(serde::de::Error::duplicate_field("versionDeltas"));
10804 }
10805 version_deltas__ = map_.next_value()?;
10806 }
10807 }
10808 }
10809 Ok(ListVersionDeltasResponse {
10810 version_deltas: version_deltas__,
10811 })
10812 }
10813 }
10814 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
10815 }
10816}
10817impl serde::Serialize for MergeCompactionGroupRequest {
10818 #[allow(deprecated)]
10819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10820 where
10821 S: serde::Serializer,
10822 {
10823 use serde::ser::SerializeStruct;
10824 let mut len = 0;
10825 if self.left_group_id != 0 {
10826 len += 1;
10827 }
10828 if self.right_group_id != 0 {
10829 len += 1;
10830 }
10831 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
10832 if self.left_group_id != 0 {
10833 #[allow(clippy::needless_borrow)]
10834 #[allow(clippy::needless_borrows_for_generic_args)]
10835 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
10836 }
10837 if self.right_group_id != 0 {
10838 #[allow(clippy::needless_borrow)]
10839 #[allow(clippy::needless_borrows_for_generic_args)]
10840 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
10841 }
10842 struct_ser.end()
10843 }
10844}
10845impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
10846 #[allow(deprecated)]
10847 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10848 where
10849 D: serde::Deserializer<'de>,
10850 {
10851 const FIELDS: &[&str] = &[
10852 "left_group_id",
10853 "leftGroupId",
10854 "right_group_id",
10855 "rightGroupId",
10856 ];
10857
10858 #[allow(clippy::enum_variant_names)]
10859 enum GeneratedField {
10860 LeftGroupId,
10861 RightGroupId,
10862 }
10863 impl<'de> serde::Deserialize<'de> for GeneratedField {
10864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10865 where
10866 D: serde::Deserializer<'de>,
10867 {
10868 struct GeneratedVisitor;
10869
10870 impl serde::de::Visitor<'_> for GeneratedVisitor {
10871 type Value = GeneratedField;
10872
10873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10874 write!(formatter, "expected one of: {:?}", &FIELDS)
10875 }
10876
10877 #[allow(unused_variables)]
10878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10879 where
10880 E: serde::de::Error,
10881 {
10882 match value {
10883 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
10884 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
10885 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10886 }
10887 }
10888 }
10889 deserializer.deserialize_identifier(GeneratedVisitor)
10890 }
10891 }
10892 struct GeneratedVisitor;
10893 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10894 type Value = MergeCompactionGroupRequest;
10895
10896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10897 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
10898 }
10899
10900 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
10901 where
10902 V: serde::de::MapAccess<'de>,
10903 {
10904 let mut left_group_id__ = None;
10905 let mut right_group_id__ = None;
10906 while let Some(k) = map_.next_key()? {
10907 match k {
10908 GeneratedField::LeftGroupId => {
10909 if left_group_id__.is_some() {
10910 return Err(serde::de::Error::duplicate_field("leftGroupId"));
10911 }
10912 left_group_id__ =
10913 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10914 ;
10915 }
10916 GeneratedField::RightGroupId => {
10917 if right_group_id__.is_some() {
10918 return Err(serde::de::Error::duplicate_field("rightGroupId"));
10919 }
10920 right_group_id__ =
10921 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10922 ;
10923 }
10924 }
10925 }
10926 Ok(MergeCompactionGroupRequest {
10927 left_group_id: left_group_id__.unwrap_or_default(),
10928 right_group_id: right_group_id__.unwrap_or_default(),
10929 })
10930 }
10931 }
10932 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
10933 }
10934}
10935impl serde::Serialize for MergeCompactionGroupResponse {
10936 #[allow(deprecated)]
10937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10938 where
10939 S: serde::Serializer,
10940 {
10941 use serde::ser::SerializeStruct;
10942 let len = 0;
10943 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
10944 struct_ser.end()
10945 }
10946}
10947impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
10948 #[allow(deprecated)]
10949 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10950 where
10951 D: serde::Deserializer<'de>,
10952 {
10953 const FIELDS: &[&str] = &[
10954 ];
10955
10956 #[allow(clippy::enum_variant_names)]
10957 enum GeneratedField {
10958 }
10959 impl<'de> serde::Deserialize<'de> for GeneratedField {
10960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10961 where
10962 D: serde::Deserializer<'de>,
10963 {
10964 struct GeneratedVisitor;
10965
10966 impl serde::de::Visitor<'_> for GeneratedVisitor {
10967 type Value = GeneratedField;
10968
10969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10970 write!(formatter, "expected one of: {:?}", &FIELDS)
10971 }
10972
10973 #[allow(unused_variables)]
10974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10975 where
10976 E: serde::de::Error,
10977 {
10978 Err(serde::de::Error::unknown_field(value, FIELDS))
10979 }
10980 }
10981 deserializer.deserialize_identifier(GeneratedVisitor)
10982 }
10983 }
10984 struct GeneratedVisitor;
10985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10986 type Value = MergeCompactionGroupResponse;
10987
10988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10989 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
10990 }
10991
10992 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
10993 where
10994 V: serde::de::MapAccess<'de>,
10995 {
10996 while map_.next_key::<GeneratedField>()?.is_some() {
10997 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10998 }
10999 Ok(MergeCompactionGroupResponse {
11000 })
11001 }
11002 }
11003 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
11004 }
11005}
11006impl serde::Serialize for NewL0SubLevel {
11007 #[allow(deprecated)]
11008 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11009 where
11010 S: serde::Serializer,
11011 {
11012 use serde::ser::SerializeStruct;
11013 let mut len = 0;
11014 if !self.inserted_table_infos.is_empty() {
11015 len += 1;
11016 }
11017 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
11018 if !self.inserted_table_infos.is_empty() {
11019 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
11020 }
11021 struct_ser.end()
11022 }
11023}
11024impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
11025 #[allow(deprecated)]
11026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11027 where
11028 D: serde::Deserializer<'de>,
11029 {
11030 const FIELDS: &[&str] = &[
11031 "inserted_table_infos",
11032 "insertedTableInfos",
11033 ];
11034
11035 #[allow(clippy::enum_variant_names)]
11036 enum GeneratedField {
11037 InsertedTableInfos,
11038 }
11039 impl<'de> serde::Deserialize<'de> for GeneratedField {
11040 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11041 where
11042 D: serde::Deserializer<'de>,
11043 {
11044 struct GeneratedVisitor;
11045
11046 impl serde::de::Visitor<'_> for GeneratedVisitor {
11047 type Value = GeneratedField;
11048
11049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11050 write!(formatter, "expected one of: {:?}", &FIELDS)
11051 }
11052
11053 #[allow(unused_variables)]
11054 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11055 where
11056 E: serde::de::Error,
11057 {
11058 match value {
11059 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
11060 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11061 }
11062 }
11063 }
11064 deserializer.deserialize_identifier(GeneratedVisitor)
11065 }
11066 }
11067 struct GeneratedVisitor;
11068 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11069 type Value = NewL0SubLevel;
11070
11071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11072 formatter.write_str("struct hummock.NewL0SubLevel")
11073 }
11074
11075 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
11076 where
11077 V: serde::de::MapAccess<'de>,
11078 {
11079 let mut inserted_table_infos__ = None;
11080 while let Some(k) = map_.next_key()? {
11081 match k {
11082 GeneratedField::InsertedTableInfos => {
11083 if inserted_table_infos__.is_some() {
11084 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
11085 }
11086 inserted_table_infos__ = Some(map_.next_value()?);
11087 }
11088 }
11089 }
11090 Ok(NewL0SubLevel {
11091 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
11092 })
11093 }
11094 }
11095 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
11096 }
11097}
11098impl serde::Serialize for OverlappingLevel {
11099 #[allow(deprecated)]
11100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11101 where
11102 S: serde::Serializer,
11103 {
11104 use serde::ser::SerializeStruct;
11105 let mut len = 0;
11106 if !self.sub_levels.is_empty() {
11107 len += 1;
11108 }
11109 if self.total_file_size != 0 {
11110 len += 1;
11111 }
11112 if self.uncompressed_file_size != 0 {
11113 len += 1;
11114 }
11115 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
11116 if !self.sub_levels.is_empty() {
11117 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
11118 }
11119 if self.total_file_size != 0 {
11120 #[allow(clippy::needless_borrow)]
11121 #[allow(clippy::needless_borrows_for_generic_args)]
11122 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
11123 }
11124 if self.uncompressed_file_size != 0 {
11125 #[allow(clippy::needless_borrow)]
11126 #[allow(clippy::needless_borrows_for_generic_args)]
11127 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
11128 }
11129 struct_ser.end()
11130 }
11131}
11132impl<'de> serde::Deserialize<'de> for OverlappingLevel {
11133 #[allow(deprecated)]
11134 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11135 where
11136 D: serde::Deserializer<'de>,
11137 {
11138 const FIELDS: &[&str] = &[
11139 "sub_levels",
11140 "subLevels",
11141 "total_file_size",
11142 "totalFileSize",
11143 "uncompressed_file_size",
11144 "uncompressedFileSize",
11145 ];
11146
11147 #[allow(clippy::enum_variant_names)]
11148 enum GeneratedField {
11149 SubLevels,
11150 TotalFileSize,
11151 UncompressedFileSize,
11152 }
11153 impl<'de> serde::Deserialize<'de> for GeneratedField {
11154 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11155 where
11156 D: serde::Deserializer<'de>,
11157 {
11158 struct GeneratedVisitor;
11159
11160 impl serde::de::Visitor<'_> for GeneratedVisitor {
11161 type Value = GeneratedField;
11162
11163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11164 write!(formatter, "expected one of: {:?}", &FIELDS)
11165 }
11166
11167 #[allow(unused_variables)]
11168 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11169 where
11170 E: serde::de::Error,
11171 {
11172 match value {
11173 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
11174 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
11175 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
11176 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11177 }
11178 }
11179 }
11180 deserializer.deserialize_identifier(GeneratedVisitor)
11181 }
11182 }
11183 struct GeneratedVisitor;
11184 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11185 type Value = OverlappingLevel;
11186
11187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11188 formatter.write_str("struct hummock.OverlappingLevel")
11189 }
11190
11191 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
11192 where
11193 V: serde::de::MapAccess<'de>,
11194 {
11195 let mut sub_levels__ = None;
11196 let mut total_file_size__ = None;
11197 let mut uncompressed_file_size__ = None;
11198 while let Some(k) = map_.next_key()? {
11199 match k {
11200 GeneratedField::SubLevels => {
11201 if sub_levels__.is_some() {
11202 return Err(serde::de::Error::duplicate_field("subLevels"));
11203 }
11204 sub_levels__ = Some(map_.next_value()?);
11205 }
11206 GeneratedField::TotalFileSize => {
11207 if total_file_size__.is_some() {
11208 return Err(serde::de::Error::duplicate_field("totalFileSize"));
11209 }
11210 total_file_size__ =
11211 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11212 ;
11213 }
11214 GeneratedField::UncompressedFileSize => {
11215 if uncompressed_file_size__.is_some() {
11216 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
11217 }
11218 uncompressed_file_size__ =
11219 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11220 ;
11221 }
11222 }
11223 }
11224 Ok(OverlappingLevel {
11225 sub_levels: sub_levels__.unwrap_or_default(),
11226 total_file_size: total_file_size__.unwrap_or_default(),
11227 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
11228 })
11229 }
11230 }
11231 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
11232 }
11233}
11234impl serde::Serialize for PinVersionRequest {
11235 #[allow(deprecated)]
11236 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11237 where
11238 S: serde::Serializer,
11239 {
11240 use serde::ser::SerializeStruct;
11241 let mut len = 0;
11242 if self.context_id != 0 {
11243 len += 1;
11244 }
11245 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
11246 if self.context_id != 0 {
11247 struct_ser.serialize_field("contextId", &self.context_id)?;
11248 }
11249 struct_ser.end()
11250 }
11251}
11252impl<'de> serde::Deserialize<'de> for PinVersionRequest {
11253 #[allow(deprecated)]
11254 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11255 where
11256 D: serde::Deserializer<'de>,
11257 {
11258 const FIELDS: &[&str] = &[
11259 "context_id",
11260 "contextId",
11261 ];
11262
11263 #[allow(clippy::enum_variant_names)]
11264 enum GeneratedField {
11265 ContextId,
11266 }
11267 impl<'de> serde::Deserialize<'de> for GeneratedField {
11268 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11269 where
11270 D: serde::Deserializer<'de>,
11271 {
11272 struct GeneratedVisitor;
11273
11274 impl serde::de::Visitor<'_> for GeneratedVisitor {
11275 type Value = GeneratedField;
11276
11277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11278 write!(formatter, "expected one of: {:?}", &FIELDS)
11279 }
11280
11281 #[allow(unused_variables)]
11282 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11283 where
11284 E: serde::de::Error,
11285 {
11286 match value {
11287 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
11288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11289 }
11290 }
11291 }
11292 deserializer.deserialize_identifier(GeneratedVisitor)
11293 }
11294 }
11295 struct GeneratedVisitor;
11296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11297 type Value = PinVersionRequest;
11298
11299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11300 formatter.write_str("struct hummock.PinVersionRequest")
11301 }
11302
11303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
11304 where
11305 V: serde::de::MapAccess<'de>,
11306 {
11307 let mut context_id__ = None;
11308 while let Some(k) = map_.next_key()? {
11309 match k {
11310 GeneratedField::ContextId => {
11311 if context_id__.is_some() {
11312 return Err(serde::de::Error::duplicate_field("contextId"));
11313 }
11314 context_id__ =
11315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11316 ;
11317 }
11318 }
11319 }
11320 Ok(PinVersionRequest {
11321 context_id: context_id__.unwrap_or_default(),
11322 })
11323 }
11324 }
11325 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
11326 }
11327}
11328impl serde::Serialize for PinVersionResponse {
11329 #[allow(deprecated)]
11330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11331 where
11332 S: serde::Serializer,
11333 {
11334 use serde::ser::SerializeStruct;
11335 let mut len = 0;
11336 if self.pinned_version.is_some() {
11337 len += 1;
11338 }
11339 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
11340 if let Some(v) = self.pinned_version.as_ref() {
11341 struct_ser.serialize_field("pinnedVersion", v)?;
11342 }
11343 struct_ser.end()
11344 }
11345}
11346impl<'de> serde::Deserialize<'de> for PinVersionResponse {
11347 #[allow(deprecated)]
11348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11349 where
11350 D: serde::Deserializer<'de>,
11351 {
11352 const FIELDS: &[&str] = &[
11353 "pinned_version",
11354 "pinnedVersion",
11355 ];
11356
11357 #[allow(clippy::enum_variant_names)]
11358 enum GeneratedField {
11359 PinnedVersion,
11360 }
11361 impl<'de> serde::Deserialize<'de> for GeneratedField {
11362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11363 where
11364 D: serde::Deserializer<'de>,
11365 {
11366 struct GeneratedVisitor;
11367
11368 impl serde::de::Visitor<'_> for GeneratedVisitor {
11369 type Value = GeneratedField;
11370
11371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11372 write!(formatter, "expected one of: {:?}", &FIELDS)
11373 }
11374
11375 #[allow(unused_variables)]
11376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11377 where
11378 E: serde::de::Error,
11379 {
11380 match value {
11381 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
11382 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11383 }
11384 }
11385 }
11386 deserializer.deserialize_identifier(GeneratedVisitor)
11387 }
11388 }
11389 struct GeneratedVisitor;
11390 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11391 type Value = PinVersionResponse;
11392
11393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11394 formatter.write_str("struct hummock.PinVersionResponse")
11395 }
11396
11397 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
11398 where
11399 V: serde::de::MapAccess<'de>,
11400 {
11401 let mut pinned_version__ = None;
11402 while let Some(k) = map_.next_key()? {
11403 match k {
11404 GeneratedField::PinnedVersion => {
11405 if pinned_version__.is_some() {
11406 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
11407 }
11408 pinned_version__ = map_.next_value()?;
11409 }
11410 }
11411 }
11412 Ok(PinVersionResponse {
11413 pinned_version: pinned_version__,
11414 })
11415 }
11416 }
11417 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
11418 }
11419}
11420impl serde::Serialize for PinnedVersionsSummary {
11421 #[allow(deprecated)]
11422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11423 where
11424 S: serde::Serializer,
11425 {
11426 use serde::ser::SerializeStruct;
11427 let mut len = 0;
11428 if !self.pinned_versions.is_empty() {
11429 len += 1;
11430 }
11431 if !self.workers.is_empty() {
11432 len += 1;
11433 }
11434 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
11435 if !self.pinned_versions.is_empty() {
11436 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
11437 }
11438 if !self.workers.is_empty() {
11439 struct_ser.serialize_field("workers", &self.workers)?;
11440 }
11441 struct_ser.end()
11442 }
11443}
11444impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
11445 #[allow(deprecated)]
11446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11447 where
11448 D: serde::Deserializer<'de>,
11449 {
11450 const FIELDS: &[&str] = &[
11451 "pinned_versions",
11452 "pinnedVersions",
11453 "workers",
11454 ];
11455
11456 #[allow(clippy::enum_variant_names)]
11457 enum GeneratedField {
11458 PinnedVersions,
11459 Workers,
11460 }
11461 impl<'de> serde::Deserialize<'de> for GeneratedField {
11462 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11463 where
11464 D: serde::Deserializer<'de>,
11465 {
11466 struct GeneratedVisitor;
11467
11468 impl serde::de::Visitor<'_> for GeneratedVisitor {
11469 type Value = GeneratedField;
11470
11471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11472 write!(formatter, "expected one of: {:?}", &FIELDS)
11473 }
11474
11475 #[allow(unused_variables)]
11476 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11477 where
11478 E: serde::de::Error,
11479 {
11480 match value {
11481 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
11482 "workers" => Ok(GeneratedField::Workers),
11483 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11484 }
11485 }
11486 }
11487 deserializer.deserialize_identifier(GeneratedVisitor)
11488 }
11489 }
11490 struct GeneratedVisitor;
11491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11492 type Value = PinnedVersionsSummary;
11493
11494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11495 formatter.write_str("struct hummock.PinnedVersionsSummary")
11496 }
11497
11498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
11499 where
11500 V: serde::de::MapAccess<'de>,
11501 {
11502 let mut pinned_versions__ = None;
11503 let mut workers__ = None;
11504 while let Some(k) = map_.next_key()? {
11505 match k {
11506 GeneratedField::PinnedVersions => {
11507 if pinned_versions__.is_some() {
11508 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
11509 }
11510 pinned_versions__ = Some(map_.next_value()?);
11511 }
11512 GeneratedField::Workers => {
11513 if workers__.is_some() {
11514 return Err(serde::de::Error::duplicate_field("workers"));
11515 }
11516 workers__ = Some(
11517 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11518 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11519 );
11520 }
11521 }
11522 }
11523 Ok(PinnedVersionsSummary {
11524 pinned_versions: pinned_versions__.unwrap_or_default(),
11525 workers: workers__.unwrap_or_default(),
11526 })
11527 }
11528 }
11529 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
11530 }
11531}
11532impl serde::Serialize for ReplayVersionDeltaRequest {
11533 #[allow(deprecated)]
11534 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11535 where
11536 S: serde::Serializer,
11537 {
11538 use serde::ser::SerializeStruct;
11539 let mut len = 0;
11540 if self.version_delta.is_some() {
11541 len += 1;
11542 }
11543 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
11544 if let Some(v) = self.version_delta.as_ref() {
11545 struct_ser.serialize_field("versionDelta", v)?;
11546 }
11547 struct_ser.end()
11548 }
11549}
11550impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
11551 #[allow(deprecated)]
11552 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11553 where
11554 D: serde::Deserializer<'de>,
11555 {
11556 const FIELDS: &[&str] = &[
11557 "version_delta",
11558 "versionDelta",
11559 ];
11560
11561 #[allow(clippy::enum_variant_names)]
11562 enum GeneratedField {
11563 VersionDelta,
11564 }
11565 impl<'de> serde::Deserialize<'de> for GeneratedField {
11566 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11567 where
11568 D: serde::Deserializer<'de>,
11569 {
11570 struct GeneratedVisitor;
11571
11572 impl serde::de::Visitor<'_> for GeneratedVisitor {
11573 type Value = GeneratedField;
11574
11575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11576 write!(formatter, "expected one of: {:?}", &FIELDS)
11577 }
11578
11579 #[allow(unused_variables)]
11580 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11581 where
11582 E: serde::de::Error,
11583 {
11584 match value {
11585 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
11586 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11587 }
11588 }
11589 }
11590 deserializer.deserialize_identifier(GeneratedVisitor)
11591 }
11592 }
11593 struct GeneratedVisitor;
11594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11595 type Value = ReplayVersionDeltaRequest;
11596
11597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11598 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
11599 }
11600
11601 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
11602 where
11603 V: serde::de::MapAccess<'de>,
11604 {
11605 let mut version_delta__ = None;
11606 while let Some(k) = map_.next_key()? {
11607 match k {
11608 GeneratedField::VersionDelta => {
11609 if version_delta__.is_some() {
11610 return Err(serde::de::Error::duplicate_field("versionDelta"));
11611 }
11612 version_delta__ = map_.next_value()?;
11613 }
11614 }
11615 }
11616 Ok(ReplayVersionDeltaRequest {
11617 version_delta: version_delta__,
11618 })
11619 }
11620 }
11621 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
11622 }
11623}
11624impl serde::Serialize for ReplayVersionDeltaResponse {
11625 #[allow(deprecated)]
11626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11627 where
11628 S: serde::Serializer,
11629 {
11630 use serde::ser::SerializeStruct;
11631 let mut len = 0;
11632 if self.version.is_some() {
11633 len += 1;
11634 }
11635 if !self.modified_compaction_groups.is_empty() {
11636 len += 1;
11637 }
11638 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
11639 if let Some(v) = self.version.as_ref() {
11640 struct_ser.serialize_field("version", v)?;
11641 }
11642 if !self.modified_compaction_groups.is_empty() {
11643 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
11644 }
11645 struct_ser.end()
11646 }
11647}
11648impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
11649 #[allow(deprecated)]
11650 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11651 where
11652 D: serde::Deserializer<'de>,
11653 {
11654 const FIELDS: &[&str] = &[
11655 "version",
11656 "modified_compaction_groups",
11657 "modifiedCompactionGroups",
11658 ];
11659
11660 #[allow(clippy::enum_variant_names)]
11661 enum GeneratedField {
11662 Version,
11663 ModifiedCompactionGroups,
11664 }
11665 impl<'de> serde::Deserialize<'de> for GeneratedField {
11666 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11667 where
11668 D: serde::Deserializer<'de>,
11669 {
11670 struct GeneratedVisitor;
11671
11672 impl serde::de::Visitor<'_> for GeneratedVisitor {
11673 type Value = GeneratedField;
11674
11675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11676 write!(formatter, "expected one of: {:?}", &FIELDS)
11677 }
11678
11679 #[allow(unused_variables)]
11680 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11681 where
11682 E: serde::de::Error,
11683 {
11684 match value {
11685 "version" => Ok(GeneratedField::Version),
11686 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
11687 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11688 }
11689 }
11690 }
11691 deserializer.deserialize_identifier(GeneratedVisitor)
11692 }
11693 }
11694 struct GeneratedVisitor;
11695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11696 type Value = ReplayVersionDeltaResponse;
11697
11698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11699 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
11700 }
11701
11702 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
11703 where
11704 V: serde::de::MapAccess<'de>,
11705 {
11706 let mut version__ = None;
11707 let mut modified_compaction_groups__ = None;
11708 while let Some(k) = map_.next_key()? {
11709 match k {
11710 GeneratedField::Version => {
11711 if version__.is_some() {
11712 return Err(serde::de::Error::duplicate_field("version"));
11713 }
11714 version__ = map_.next_value()?;
11715 }
11716 GeneratedField::ModifiedCompactionGroups => {
11717 if modified_compaction_groups__.is_some() {
11718 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
11719 }
11720 modified_compaction_groups__ =
11721 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11722 .into_iter().map(|x| x.0).collect())
11723 ;
11724 }
11725 }
11726 }
11727 Ok(ReplayVersionDeltaResponse {
11728 version: version__,
11729 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
11730 })
11731 }
11732 }
11733 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
11734 }
11735}
11736impl serde::Serialize for ReportCompactionTaskRequest {
11737 #[allow(deprecated)]
11738 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11739 where
11740 S: serde::Serializer,
11741 {
11742 use serde::ser::SerializeStruct;
11743 let mut len = 0;
11744 if self.event.is_some() {
11745 len += 1;
11746 }
11747 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
11748 if let Some(v) = self.event.as_ref() {
11749 match v {
11750 report_compaction_task_request::Event::ReportTask(v) => {
11751 struct_ser.serialize_field("reportTask", v)?;
11752 }
11753 report_compaction_task_request::Event::HeartBeat(v) => {
11754 struct_ser.serialize_field("heartBeat", v)?;
11755 }
11756 }
11757 }
11758 struct_ser.end()
11759 }
11760}
11761impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
11762 #[allow(deprecated)]
11763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11764 where
11765 D: serde::Deserializer<'de>,
11766 {
11767 const FIELDS: &[&str] = &[
11768 "report_task",
11769 "reportTask",
11770 "heart_beat",
11771 "heartBeat",
11772 ];
11773
11774 #[allow(clippy::enum_variant_names)]
11775 enum GeneratedField {
11776 ReportTask,
11777 HeartBeat,
11778 }
11779 impl<'de> serde::Deserialize<'de> for GeneratedField {
11780 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11781 where
11782 D: serde::Deserializer<'de>,
11783 {
11784 struct GeneratedVisitor;
11785
11786 impl serde::de::Visitor<'_> for GeneratedVisitor {
11787 type Value = GeneratedField;
11788
11789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11790 write!(formatter, "expected one of: {:?}", &FIELDS)
11791 }
11792
11793 #[allow(unused_variables)]
11794 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11795 where
11796 E: serde::de::Error,
11797 {
11798 match value {
11799 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
11800 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
11801 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11802 }
11803 }
11804 }
11805 deserializer.deserialize_identifier(GeneratedVisitor)
11806 }
11807 }
11808 struct GeneratedVisitor;
11809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11810 type Value = ReportCompactionTaskRequest;
11811
11812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11813 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
11814 }
11815
11816 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
11817 where
11818 V: serde::de::MapAccess<'de>,
11819 {
11820 let mut event__ = None;
11821 while let Some(k) = map_.next_key()? {
11822 match k {
11823 GeneratedField::ReportTask => {
11824 if event__.is_some() {
11825 return Err(serde::de::Error::duplicate_field("reportTask"));
11826 }
11827 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
11828;
11829 }
11830 GeneratedField::HeartBeat => {
11831 if event__.is_some() {
11832 return Err(serde::de::Error::duplicate_field("heartBeat"));
11833 }
11834 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
11835;
11836 }
11837 }
11838 }
11839 Ok(ReportCompactionTaskRequest {
11840 event: event__,
11841 })
11842 }
11843 }
11844 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
11845 }
11846}
11847impl serde::Serialize for report_compaction_task_request::HeartBeat {
11848 #[allow(deprecated)]
11849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11850 where
11851 S: serde::Serializer,
11852 {
11853 use serde::ser::SerializeStruct;
11854 let mut len = 0;
11855 if !self.progress.is_empty() {
11856 len += 1;
11857 }
11858 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
11859 if !self.progress.is_empty() {
11860 struct_ser.serialize_field("progress", &self.progress)?;
11861 }
11862 struct_ser.end()
11863 }
11864}
11865impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
11866 #[allow(deprecated)]
11867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11868 where
11869 D: serde::Deserializer<'de>,
11870 {
11871 const FIELDS: &[&str] = &[
11872 "progress",
11873 ];
11874
11875 #[allow(clippy::enum_variant_names)]
11876 enum GeneratedField {
11877 Progress,
11878 }
11879 impl<'de> serde::Deserialize<'de> for GeneratedField {
11880 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11881 where
11882 D: serde::Deserializer<'de>,
11883 {
11884 struct GeneratedVisitor;
11885
11886 impl serde::de::Visitor<'_> for GeneratedVisitor {
11887 type Value = GeneratedField;
11888
11889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11890 write!(formatter, "expected one of: {:?}", &FIELDS)
11891 }
11892
11893 #[allow(unused_variables)]
11894 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11895 where
11896 E: serde::de::Error,
11897 {
11898 match value {
11899 "progress" => Ok(GeneratedField::Progress),
11900 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11901 }
11902 }
11903 }
11904 deserializer.deserialize_identifier(GeneratedVisitor)
11905 }
11906 }
11907 struct GeneratedVisitor;
11908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11909 type Value = report_compaction_task_request::HeartBeat;
11910
11911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11912 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
11913 }
11914
11915 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
11916 where
11917 V: serde::de::MapAccess<'de>,
11918 {
11919 let mut progress__ = None;
11920 while let Some(k) = map_.next_key()? {
11921 match k {
11922 GeneratedField::Progress => {
11923 if progress__.is_some() {
11924 return Err(serde::de::Error::duplicate_field("progress"));
11925 }
11926 progress__ = Some(map_.next_value()?);
11927 }
11928 }
11929 }
11930 Ok(report_compaction_task_request::HeartBeat {
11931 progress: progress__.unwrap_or_default(),
11932 })
11933 }
11934 }
11935 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
11936 }
11937}
11938impl serde::Serialize for report_compaction_task_request::ReportTask {
11939 #[allow(deprecated)]
11940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11941 where
11942 S: serde::Serializer,
11943 {
11944 use serde::ser::SerializeStruct;
11945 let mut len = 0;
11946 if self.compact_task.is_some() {
11947 len += 1;
11948 }
11949 if !self.table_stats_change.is_empty() {
11950 len += 1;
11951 }
11952 if !self.object_timestamps.is_empty() {
11953 len += 1;
11954 }
11955 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
11956 if let Some(v) = self.compact_task.as_ref() {
11957 struct_ser.serialize_field("compactTask", v)?;
11958 }
11959 if !self.table_stats_change.is_empty() {
11960 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
11961 }
11962 if !self.object_timestamps.is_empty() {
11963 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
11964 .map(|(k, v)| (k, v.to_string())).collect();
11965 struct_ser.serialize_field("objectTimestamps", &v)?;
11966 }
11967 struct_ser.end()
11968 }
11969}
11970impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
11971 #[allow(deprecated)]
11972 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11973 where
11974 D: serde::Deserializer<'de>,
11975 {
11976 const FIELDS: &[&str] = &[
11977 "compact_task",
11978 "compactTask",
11979 "table_stats_change",
11980 "tableStatsChange",
11981 "object_timestamps",
11982 "objectTimestamps",
11983 ];
11984
11985 #[allow(clippy::enum_variant_names)]
11986 enum GeneratedField {
11987 CompactTask,
11988 TableStatsChange,
11989 ObjectTimestamps,
11990 }
11991 impl<'de> serde::Deserialize<'de> for GeneratedField {
11992 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11993 where
11994 D: serde::Deserializer<'de>,
11995 {
11996 struct GeneratedVisitor;
11997
11998 impl serde::de::Visitor<'_> for GeneratedVisitor {
11999 type Value = GeneratedField;
12000
12001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12002 write!(formatter, "expected one of: {:?}", &FIELDS)
12003 }
12004
12005 #[allow(unused_variables)]
12006 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12007 where
12008 E: serde::de::Error,
12009 {
12010 match value {
12011 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
12012 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
12013 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
12014 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12015 }
12016 }
12017 }
12018 deserializer.deserialize_identifier(GeneratedVisitor)
12019 }
12020 }
12021 struct GeneratedVisitor;
12022 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12023 type Value = report_compaction_task_request::ReportTask;
12024
12025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12026 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
12027 }
12028
12029 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
12030 where
12031 V: serde::de::MapAccess<'de>,
12032 {
12033 let mut compact_task__ = None;
12034 let mut table_stats_change__ = None;
12035 let mut object_timestamps__ = None;
12036 while let Some(k) = map_.next_key()? {
12037 match k {
12038 GeneratedField::CompactTask => {
12039 if compact_task__.is_some() {
12040 return Err(serde::de::Error::duplicate_field("compactTask"));
12041 }
12042 compact_task__ = map_.next_value()?;
12043 }
12044 GeneratedField::TableStatsChange => {
12045 if table_stats_change__.is_some() {
12046 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
12047 }
12048 table_stats_change__ = Some(
12049 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12050 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12051 );
12052 }
12053 GeneratedField::ObjectTimestamps => {
12054 if object_timestamps__.is_some() {
12055 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
12056 }
12057 object_timestamps__ = Some(
12058 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
12059 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
12060 );
12061 }
12062 }
12063 }
12064 Ok(report_compaction_task_request::ReportTask {
12065 compact_task: compact_task__,
12066 table_stats_change: table_stats_change__.unwrap_or_default(),
12067 object_timestamps: object_timestamps__.unwrap_or_default(),
12068 })
12069 }
12070 }
12071 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
12072 }
12073}
12074impl serde::Serialize for ReportCompactionTaskResponse {
12075 #[allow(deprecated)]
12076 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12077 where
12078 S: serde::Serializer,
12079 {
12080 use serde::ser::SerializeStruct;
12081 let mut len = 0;
12082 if self.status.is_some() {
12083 len += 1;
12084 }
12085 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
12086 if let Some(v) = self.status.as_ref() {
12087 struct_ser.serialize_field("status", v)?;
12088 }
12089 struct_ser.end()
12090 }
12091}
12092impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
12093 #[allow(deprecated)]
12094 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12095 where
12096 D: serde::Deserializer<'de>,
12097 {
12098 const FIELDS: &[&str] = &[
12099 "status",
12100 ];
12101
12102 #[allow(clippy::enum_variant_names)]
12103 enum GeneratedField {
12104 Status,
12105 }
12106 impl<'de> serde::Deserialize<'de> for GeneratedField {
12107 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12108 where
12109 D: serde::Deserializer<'de>,
12110 {
12111 struct GeneratedVisitor;
12112
12113 impl serde::de::Visitor<'_> for GeneratedVisitor {
12114 type Value = GeneratedField;
12115
12116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12117 write!(formatter, "expected one of: {:?}", &FIELDS)
12118 }
12119
12120 #[allow(unused_variables)]
12121 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12122 where
12123 E: serde::de::Error,
12124 {
12125 match value {
12126 "status" => Ok(GeneratedField::Status),
12127 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12128 }
12129 }
12130 }
12131 deserializer.deserialize_identifier(GeneratedVisitor)
12132 }
12133 }
12134 struct GeneratedVisitor;
12135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12136 type Value = ReportCompactionTaskResponse;
12137
12138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12139 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
12140 }
12141
12142 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
12143 where
12144 V: serde::de::MapAccess<'de>,
12145 {
12146 let mut status__ = None;
12147 while let Some(k) = map_.next_key()? {
12148 match k {
12149 GeneratedField::Status => {
12150 if status__.is_some() {
12151 return Err(serde::de::Error::duplicate_field("status"));
12152 }
12153 status__ = map_.next_value()?;
12154 }
12155 }
12156 }
12157 Ok(ReportCompactionTaskResponse {
12158 status: status__,
12159 })
12160 }
12161 }
12162 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
12163 }
12164}
12165impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
12166 #[allow(deprecated)]
12167 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12168 where
12169 S: serde::Serializer,
12170 {
12171 use serde::ser::SerializeStruct;
12172 let len = 0;
12173 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
12174 struct_ser.end()
12175 }
12176}
12177impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
12178 #[allow(deprecated)]
12179 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12180 where
12181 D: serde::Deserializer<'de>,
12182 {
12183 const FIELDS: &[&str] = &[
12184 ];
12185
12186 #[allow(clippy::enum_variant_names)]
12187 enum GeneratedField {
12188 }
12189 impl<'de> serde::Deserialize<'de> for GeneratedField {
12190 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12191 where
12192 D: serde::Deserializer<'de>,
12193 {
12194 struct GeneratedVisitor;
12195
12196 impl serde::de::Visitor<'_> for GeneratedVisitor {
12197 type Value = GeneratedField;
12198
12199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12200 write!(formatter, "expected one of: {:?}", &FIELDS)
12201 }
12202
12203 #[allow(unused_variables)]
12204 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12205 where
12206 E: serde::de::Error,
12207 {
12208 Err(serde::de::Error::unknown_field(value, FIELDS))
12209 }
12210 }
12211 deserializer.deserialize_identifier(GeneratedVisitor)
12212 }
12213 }
12214 struct GeneratedVisitor;
12215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12216 type Value = RiseCtlGetCheckpointVersionRequest;
12217
12218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12219 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
12220 }
12221
12222 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
12223 where
12224 V: serde::de::MapAccess<'de>,
12225 {
12226 while map_.next_key::<GeneratedField>()?.is_some() {
12227 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12228 }
12229 Ok(RiseCtlGetCheckpointVersionRequest {
12230 })
12231 }
12232 }
12233 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
12234 }
12235}
12236impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
12237 #[allow(deprecated)]
12238 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12239 where
12240 S: serde::Serializer,
12241 {
12242 use serde::ser::SerializeStruct;
12243 let mut len = 0;
12244 if self.checkpoint_version.is_some() {
12245 len += 1;
12246 }
12247 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
12248 if let Some(v) = self.checkpoint_version.as_ref() {
12249 struct_ser.serialize_field("checkpointVersion", v)?;
12250 }
12251 struct_ser.end()
12252 }
12253}
12254impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
12255 #[allow(deprecated)]
12256 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12257 where
12258 D: serde::Deserializer<'de>,
12259 {
12260 const FIELDS: &[&str] = &[
12261 "checkpoint_version",
12262 "checkpointVersion",
12263 ];
12264
12265 #[allow(clippy::enum_variant_names)]
12266 enum GeneratedField {
12267 CheckpointVersion,
12268 }
12269 impl<'de> serde::Deserialize<'de> for GeneratedField {
12270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12271 where
12272 D: serde::Deserializer<'de>,
12273 {
12274 struct GeneratedVisitor;
12275
12276 impl serde::de::Visitor<'_> for GeneratedVisitor {
12277 type Value = GeneratedField;
12278
12279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12280 write!(formatter, "expected one of: {:?}", &FIELDS)
12281 }
12282
12283 #[allow(unused_variables)]
12284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12285 where
12286 E: serde::de::Error,
12287 {
12288 match value {
12289 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
12290 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12291 }
12292 }
12293 }
12294 deserializer.deserialize_identifier(GeneratedVisitor)
12295 }
12296 }
12297 struct GeneratedVisitor;
12298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12299 type Value = RiseCtlGetCheckpointVersionResponse;
12300
12301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12302 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
12303 }
12304
12305 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
12306 where
12307 V: serde::de::MapAccess<'de>,
12308 {
12309 let mut checkpoint_version__ = None;
12310 while let Some(k) = map_.next_key()? {
12311 match k {
12312 GeneratedField::CheckpointVersion => {
12313 if checkpoint_version__.is_some() {
12314 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
12315 }
12316 checkpoint_version__ = map_.next_value()?;
12317 }
12318 }
12319 }
12320 Ok(RiseCtlGetCheckpointVersionResponse {
12321 checkpoint_version: checkpoint_version__,
12322 })
12323 }
12324 }
12325 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
12326 }
12327}
12328impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
12329 #[allow(deprecated)]
12330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12331 where
12332 S: serde::Serializer,
12333 {
12334 use serde::ser::SerializeStruct;
12335 let len = 0;
12336 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
12337 struct_ser.end()
12338 }
12339}
12340impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
12341 #[allow(deprecated)]
12342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12343 where
12344 D: serde::Deserializer<'de>,
12345 {
12346 const FIELDS: &[&str] = &[
12347 ];
12348
12349 #[allow(clippy::enum_variant_names)]
12350 enum GeneratedField {
12351 }
12352 impl<'de> serde::Deserialize<'de> for GeneratedField {
12353 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12354 where
12355 D: serde::Deserializer<'de>,
12356 {
12357 struct GeneratedVisitor;
12358
12359 impl serde::de::Visitor<'_> for GeneratedVisitor {
12360 type Value = GeneratedField;
12361
12362 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12363 write!(formatter, "expected one of: {:?}", &FIELDS)
12364 }
12365
12366 #[allow(unused_variables)]
12367 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12368 where
12369 E: serde::de::Error,
12370 {
12371 Err(serde::de::Error::unknown_field(value, FIELDS))
12372 }
12373 }
12374 deserializer.deserialize_identifier(GeneratedVisitor)
12375 }
12376 }
12377 struct GeneratedVisitor;
12378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12379 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
12380
12381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12382 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
12383 }
12384
12385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
12386 where
12387 V: serde::de::MapAccess<'de>,
12388 {
12389 while map_.next_key::<GeneratedField>()?.is_some() {
12390 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12391 }
12392 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
12393 })
12394 }
12395 }
12396 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
12397 }
12398}
12399impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
12400 #[allow(deprecated)]
12401 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12402 where
12403 S: serde::Serializer,
12404 {
12405 use serde::ser::SerializeStruct;
12406 let mut len = 0;
12407 if self.summary.is_some() {
12408 len += 1;
12409 }
12410 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
12411 if let Some(v) = self.summary.as_ref() {
12412 struct_ser.serialize_field("summary", v)?;
12413 }
12414 struct_ser.end()
12415 }
12416}
12417impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
12418 #[allow(deprecated)]
12419 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12420 where
12421 D: serde::Deserializer<'de>,
12422 {
12423 const FIELDS: &[&str] = &[
12424 "summary",
12425 ];
12426
12427 #[allow(clippy::enum_variant_names)]
12428 enum GeneratedField {
12429 Summary,
12430 }
12431 impl<'de> serde::Deserialize<'de> for GeneratedField {
12432 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12433 where
12434 D: serde::Deserializer<'de>,
12435 {
12436 struct GeneratedVisitor;
12437
12438 impl serde::de::Visitor<'_> for GeneratedVisitor {
12439 type Value = GeneratedField;
12440
12441 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12442 write!(formatter, "expected one of: {:?}", &FIELDS)
12443 }
12444
12445 #[allow(unused_variables)]
12446 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12447 where
12448 E: serde::de::Error,
12449 {
12450 match value {
12451 "summary" => Ok(GeneratedField::Summary),
12452 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12453 }
12454 }
12455 }
12456 deserializer.deserialize_identifier(GeneratedVisitor)
12457 }
12458 }
12459 struct GeneratedVisitor;
12460 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12461 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
12462
12463 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12464 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
12465 }
12466
12467 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
12468 where
12469 V: serde::de::MapAccess<'de>,
12470 {
12471 let mut summary__ = None;
12472 while let Some(k) = map_.next_key()? {
12473 match k {
12474 GeneratedField::Summary => {
12475 if summary__.is_some() {
12476 return Err(serde::de::Error::duplicate_field("summary"));
12477 }
12478 summary__ = map_.next_value()?;
12479 }
12480 }
12481 }
12482 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
12483 summary: summary__,
12484 })
12485 }
12486 }
12487 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
12488 }
12489}
12490impl serde::Serialize for RiseCtlListCompactionGroupRequest {
12491 #[allow(deprecated)]
12492 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12493 where
12494 S: serde::Serializer,
12495 {
12496 use serde::ser::SerializeStruct;
12497 let len = 0;
12498 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
12499 struct_ser.end()
12500 }
12501}
12502impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
12503 #[allow(deprecated)]
12504 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12505 where
12506 D: serde::Deserializer<'de>,
12507 {
12508 const FIELDS: &[&str] = &[
12509 ];
12510
12511 #[allow(clippy::enum_variant_names)]
12512 enum GeneratedField {
12513 }
12514 impl<'de> serde::Deserialize<'de> for GeneratedField {
12515 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12516 where
12517 D: serde::Deserializer<'de>,
12518 {
12519 struct GeneratedVisitor;
12520
12521 impl serde::de::Visitor<'_> for GeneratedVisitor {
12522 type Value = GeneratedField;
12523
12524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12525 write!(formatter, "expected one of: {:?}", &FIELDS)
12526 }
12527
12528 #[allow(unused_variables)]
12529 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12530 where
12531 E: serde::de::Error,
12532 {
12533 Err(serde::de::Error::unknown_field(value, FIELDS))
12534 }
12535 }
12536 deserializer.deserialize_identifier(GeneratedVisitor)
12537 }
12538 }
12539 struct GeneratedVisitor;
12540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12541 type Value = RiseCtlListCompactionGroupRequest;
12542
12543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12544 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
12545 }
12546
12547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
12548 where
12549 V: serde::de::MapAccess<'de>,
12550 {
12551 while map_.next_key::<GeneratedField>()?.is_some() {
12552 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12553 }
12554 Ok(RiseCtlListCompactionGroupRequest {
12555 })
12556 }
12557 }
12558 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
12559 }
12560}
12561impl serde::Serialize for RiseCtlListCompactionGroupResponse {
12562 #[allow(deprecated)]
12563 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12564 where
12565 S: serde::Serializer,
12566 {
12567 use serde::ser::SerializeStruct;
12568 let mut len = 0;
12569 if self.status.is_some() {
12570 len += 1;
12571 }
12572 if !self.compaction_groups.is_empty() {
12573 len += 1;
12574 }
12575 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
12576 if let Some(v) = self.status.as_ref() {
12577 struct_ser.serialize_field("status", v)?;
12578 }
12579 if !self.compaction_groups.is_empty() {
12580 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
12581 }
12582 struct_ser.end()
12583 }
12584}
12585impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
12586 #[allow(deprecated)]
12587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12588 where
12589 D: serde::Deserializer<'de>,
12590 {
12591 const FIELDS: &[&str] = &[
12592 "status",
12593 "compaction_groups",
12594 "compactionGroups",
12595 ];
12596
12597 #[allow(clippy::enum_variant_names)]
12598 enum GeneratedField {
12599 Status,
12600 CompactionGroups,
12601 }
12602 impl<'de> serde::Deserialize<'de> for GeneratedField {
12603 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12604 where
12605 D: serde::Deserializer<'de>,
12606 {
12607 struct GeneratedVisitor;
12608
12609 impl serde::de::Visitor<'_> for GeneratedVisitor {
12610 type Value = GeneratedField;
12611
12612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12613 write!(formatter, "expected one of: {:?}", &FIELDS)
12614 }
12615
12616 #[allow(unused_variables)]
12617 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12618 where
12619 E: serde::de::Error,
12620 {
12621 match value {
12622 "status" => Ok(GeneratedField::Status),
12623 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
12624 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12625 }
12626 }
12627 }
12628 deserializer.deserialize_identifier(GeneratedVisitor)
12629 }
12630 }
12631 struct GeneratedVisitor;
12632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12633 type Value = RiseCtlListCompactionGroupResponse;
12634
12635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12636 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
12637 }
12638
12639 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
12640 where
12641 V: serde::de::MapAccess<'de>,
12642 {
12643 let mut status__ = None;
12644 let mut compaction_groups__ = None;
12645 while let Some(k) = map_.next_key()? {
12646 match k {
12647 GeneratedField::Status => {
12648 if status__.is_some() {
12649 return Err(serde::de::Error::duplicate_field("status"));
12650 }
12651 status__ = map_.next_value()?;
12652 }
12653 GeneratedField::CompactionGroups => {
12654 if compaction_groups__.is_some() {
12655 return Err(serde::de::Error::duplicate_field("compactionGroups"));
12656 }
12657 compaction_groups__ = Some(map_.next_value()?);
12658 }
12659 }
12660 }
12661 Ok(RiseCtlListCompactionGroupResponse {
12662 status: status__,
12663 compaction_groups: compaction_groups__.unwrap_or_default(),
12664 })
12665 }
12666 }
12667 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
12668 }
12669}
12670impl serde::Serialize for RiseCtlListCompactionStatusRequest {
12671 #[allow(deprecated)]
12672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12673 where
12674 S: serde::Serializer,
12675 {
12676 use serde::ser::SerializeStruct;
12677 let len = 0;
12678 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
12679 struct_ser.end()
12680 }
12681}
12682impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
12683 #[allow(deprecated)]
12684 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12685 where
12686 D: serde::Deserializer<'de>,
12687 {
12688 const FIELDS: &[&str] = &[
12689 ];
12690
12691 #[allow(clippy::enum_variant_names)]
12692 enum GeneratedField {
12693 }
12694 impl<'de> serde::Deserialize<'de> for GeneratedField {
12695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12696 where
12697 D: serde::Deserializer<'de>,
12698 {
12699 struct GeneratedVisitor;
12700
12701 impl serde::de::Visitor<'_> for GeneratedVisitor {
12702 type Value = GeneratedField;
12703
12704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12705 write!(formatter, "expected one of: {:?}", &FIELDS)
12706 }
12707
12708 #[allow(unused_variables)]
12709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12710 where
12711 E: serde::de::Error,
12712 {
12713 Err(serde::de::Error::unknown_field(value, FIELDS))
12714 }
12715 }
12716 deserializer.deserialize_identifier(GeneratedVisitor)
12717 }
12718 }
12719 struct GeneratedVisitor;
12720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12721 type Value = RiseCtlListCompactionStatusRequest;
12722
12723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12724 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
12725 }
12726
12727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
12728 where
12729 V: serde::de::MapAccess<'de>,
12730 {
12731 while map_.next_key::<GeneratedField>()?.is_some() {
12732 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12733 }
12734 Ok(RiseCtlListCompactionStatusRequest {
12735 })
12736 }
12737 }
12738 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
12739 }
12740}
12741impl serde::Serialize for RiseCtlListCompactionStatusResponse {
12742 #[allow(deprecated)]
12743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12744 where
12745 S: serde::Serializer,
12746 {
12747 use serde::ser::SerializeStruct;
12748 let mut len = 0;
12749 if !self.compaction_statuses.is_empty() {
12750 len += 1;
12751 }
12752 if !self.task_assignment.is_empty() {
12753 len += 1;
12754 }
12755 if !self.task_progress.is_empty() {
12756 len += 1;
12757 }
12758 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
12759 if !self.compaction_statuses.is_empty() {
12760 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
12761 }
12762 if !self.task_assignment.is_empty() {
12763 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
12764 }
12765 if !self.task_progress.is_empty() {
12766 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
12767 }
12768 struct_ser.end()
12769 }
12770}
12771impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
12772 #[allow(deprecated)]
12773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12774 where
12775 D: serde::Deserializer<'de>,
12776 {
12777 const FIELDS: &[&str] = &[
12778 "compaction_statuses",
12779 "compactionStatuses",
12780 "task_assignment",
12781 "taskAssignment",
12782 "task_progress",
12783 "taskProgress",
12784 ];
12785
12786 #[allow(clippy::enum_variant_names)]
12787 enum GeneratedField {
12788 CompactionStatuses,
12789 TaskAssignment,
12790 TaskProgress,
12791 }
12792 impl<'de> serde::Deserialize<'de> for GeneratedField {
12793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12794 where
12795 D: serde::Deserializer<'de>,
12796 {
12797 struct GeneratedVisitor;
12798
12799 impl serde::de::Visitor<'_> for GeneratedVisitor {
12800 type Value = GeneratedField;
12801
12802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12803 write!(formatter, "expected one of: {:?}", &FIELDS)
12804 }
12805
12806 #[allow(unused_variables)]
12807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12808 where
12809 E: serde::de::Error,
12810 {
12811 match value {
12812 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
12813 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
12814 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
12815 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12816 }
12817 }
12818 }
12819 deserializer.deserialize_identifier(GeneratedVisitor)
12820 }
12821 }
12822 struct GeneratedVisitor;
12823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12824 type Value = RiseCtlListCompactionStatusResponse;
12825
12826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12827 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
12828 }
12829
12830 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
12831 where
12832 V: serde::de::MapAccess<'de>,
12833 {
12834 let mut compaction_statuses__ = None;
12835 let mut task_assignment__ = None;
12836 let mut task_progress__ = None;
12837 while let Some(k) = map_.next_key()? {
12838 match k {
12839 GeneratedField::CompactionStatuses => {
12840 if compaction_statuses__.is_some() {
12841 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
12842 }
12843 compaction_statuses__ = Some(map_.next_value()?);
12844 }
12845 GeneratedField::TaskAssignment => {
12846 if task_assignment__.is_some() {
12847 return Err(serde::de::Error::duplicate_field("taskAssignment"));
12848 }
12849 task_assignment__ = Some(map_.next_value()?);
12850 }
12851 GeneratedField::TaskProgress => {
12852 if task_progress__.is_some() {
12853 return Err(serde::de::Error::duplicate_field("taskProgress"));
12854 }
12855 task_progress__ = Some(map_.next_value()?);
12856 }
12857 }
12858 }
12859 Ok(RiseCtlListCompactionStatusResponse {
12860 compaction_statuses: compaction_statuses__.unwrap_or_default(),
12861 task_assignment: task_assignment__.unwrap_or_default(),
12862 task_progress: task_progress__.unwrap_or_default(),
12863 })
12864 }
12865 }
12866 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
12867 }
12868}
12869impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
12870 #[allow(deprecated)]
12871 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12872 where
12873 S: serde::Serializer,
12874 {
12875 use serde::ser::SerializeStruct;
12876 let len = 0;
12877 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
12878 struct_ser.end()
12879 }
12880}
12881impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
12882 #[allow(deprecated)]
12883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12884 where
12885 D: serde::Deserializer<'de>,
12886 {
12887 const FIELDS: &[&str] = &[
12888 ];
12889
12890 #[allow(clippy::enum_variant_names)]
12891 enum GeneratedField {
12892 }
12893 impl<'de> serde::Deserialize<'de> for GeneratedField {
12894 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12895 where
12896 D: serde::Deserializer<'de>,
12897 {
12898 struct GeneratedVisitor;
12899
12900 impl serde::de::Visitor<'_> for GeneratedVisitor {
12901 type Value = GeneratedField;
12902
12903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12904 write!(formatter, "expected one of: {:?}", &FIELDS)
12905 }
12906
12907 #[allow(unused_variables)]
12908 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12909 where
12910 E: serde::de::Error,
12911 {
12912 Err(serde::de::Error::unknown_field(value, FIELDS))
12913 }
12914 }
12915 deserializer.deserialize_identifier(GeneratedVisitor)
12916 }
12917 }
12918 struct GeneratedVisitor;
12919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12920 type Value = RiseCtlPauseVersionCheckpointRequest;
12921
12922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12923 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
12924 }
12925
12926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
12927 where
12928 V: serde::de::MapAccess<'de>,
12929 {
12930 while map_.next_key::<GeneratedField>()?.is_some() {
12931 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12932 }
12933 Ok(RiseCtlPauseVersionCheckpointRequest {
12934 })
12935 }
12936 }
12937 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12938 }
12939}
12940impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
12941 #[allow(deprecated)]
12942 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12943 where
12944 S: serde::Serializer,
12945 {
12946 use serde::ser::SerializeStruct;
12947 let len = 0;
12948 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
12949 struct_ser.end()
12950 }
12951}
12952impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
12953 #[allow(deprecated)]
12954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12955 where
12956 D: serde::Deserializer<'de>,
12957 {
12958 const FIELDS: &[&str] = &[
12959 ];
12960
12961 #[allow(clippy::enum_variant_names)]
12962 enum GeneratedField {
12963 }
12964 impl<'de> serde::Deserialize<'de> for GeneratedField {
12965 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12966 where
12967 D: serde::Deserializer<'de>,
12968 {
12969 struct GeneratedVisitor;
12970
12971 impl serde::de::Visitor<'_> for GeneratedVisitor {
12972 type Value = GeneratedField;
12973
12974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12975 write!(formatter, "expected one of: {:?}", &FIELDS)
12976 }
12977
12978 #[allow(unused_variables)]
12979 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12980 where
12981 E: serde::de::Error,
12982 {
12983 Err(serde::de::Error::unknown_field(value, FIELDS))
12984 }
12985 }
12986 deserializer.deserialize_identifier(GeneratedVisitor)
12987 }
12988 }
12989 struct GeneratedVisitor;
12990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12991 type Value = RiseCtlPauseVersionCheckpointResponse;
12992
12993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12994 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
12995 }
12996
12997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
12998 where
12999 V: serde::de::MapAccess<'de>,
13000 {
13001 while map_.next_key::<GeneratedField>()?.is_some() {
13002 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13003 }
13004 Ok(RiseCtlPauseVersionCheckpointResponse {
13005 })
13006 }
13007 }
13008 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
13009 }
13010}
13011impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
13012 #[allow(deprecated)]
13013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13014 where
13015 S: serde::Serializer,
13016 {
13017 use serde::ser::SerializeStruct;
13018 let len = 0;
13019 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
13020 struct_ser.end()
13021 }
13022}
13023impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
13024 #[allow(deprecated)]
13025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13026 where
13027 D: serde::Deserializer<'de>,
13028 {
13029 const FIELDS: &[&str] = &[
13030 ];
13031
13032 #[allow(clippy::enum_variant_names)]
13033 enum GeneratedField {
13034 }
13035 impl<'de> serde::Deserialize<'de> for GeneratedField {
13036 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13037 where
13038 D: serde::Deserializer<'de>,
13039 {
13040 struct GeneratedVisitor;
13041
13042 impl serde::de::Visitor<'_> for GeneratedVisitor {
13043 type Value = GeneratedField;
13044
13045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13046 write!(formatter, "expected one of: {:?}", &FIELDS)
13047 }
13048
13049 #[allow(unused_variables)]
13050 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13051 where
13052 E: serde::de::Error,
13053 {
13054 Err(serde::de::Error::unknown_field(value, FIELDS))
13055 }
13056 }
13057 deserializer.deserialize_identifier(GeneratedVisitor)
13058 }
13059 }
13060 struct GeneratedVisitor;
13061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13062 type Value = RiseCtlRebuildTableStatsRequest;
13063
13064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13065 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
13066 }
13067
13068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
13069 where
13070 V: serde::de::MapAccess<'de>,
13071 {
13072 while map_.next_key::<GeneratedField>()?.is_some() {
13073 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13074 }
13075 Ok(RiseCtlRebuildTableStatsRequest {
13076 })
13077 }
13078 }
13079 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
13080 }
13081}
13082impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
13083 #[allow(deprecated)]
13084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13085 where
13086 S: serde::Serializer,
13087 {
13088 use serde::ser::SerializeStruct;
13089 let len = 0;
13090 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
13091 struct_ser.end()
13092 }
13093}
13094impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
13095 #[allow(deprecated)]
13096 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13097 where
13098 D: serde::Deserializer<'de>,
13099 {
13100 const FIELDS: &[&str] = &[
13101 ];
13102
13103 #[allow(clippy::enum_variant_names)]
13104 enum GeneratedField {
13105 }
13106 impl<'de> serde::Deserialize<'de> for GeneratedField {
13107 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13108 where
13109 D: serde::Deserializer<'de>,
13110 {
13111 struct GeneratedVisitor;
13112
13113 impl serde::de::Visitor<'_> for GeneratedVisitor {
13114 type Value = GeneratedField;
13115
13116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13117 write!(formatter, "expected one of: {:?}", &FIELDS)
13118 }
13119
13120 #[allow(unused_variables)]
13121 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13122 where
13123 E: serde::de::Error,
13124 {
13125 Err(serde::de::Error::unknown_field(value, FIELDS))
13126 }
13127 }
13128 deserializer.deserialize_identifier(GeneratedVisitor)
13129 }
13130 }
13131 struct GeneratedVisitor;
13132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13133 type Value = RiseCtlRebuildTableStatsResponse;
13134
13135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13136 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
13137 }
13138
13139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
13140 where
13141 V: serde::de::MapAccess<'de>,
13142 {
13143 while map_.next_key::<GeneratedField>()?.is_some() {
13144 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13145 }
13146 Ok(RiseCtlRebuildTableStatsResponse {
13147 })
13148 }
13149 }
13150 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
13151 }
13152}
13153impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
13154 #[allow(deprecated)]
13155 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13156 where
13157 S: serde::Serializer,
13158 {
13159 use serde::ser::SerializeStruct;
13160 let len = 0;
13161 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
13162 struct_ser.end()
13163 }
13164}
13165impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
13166 #[allow(deprecated)]
13167 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13168 where
13169 D: serde::Deserializer<'de>,
13170 {
13171 const FIELDS: &[&str] = &[
13172 ];
13173
13174 #[allow(clippy::enum_variant_names)]
13175 enum GeneratedField {
13176 }
13177 impl<'de> serde::Deserialize<'de> for GeneratedField {
13178 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13179 where
13180 D: serde::Deserializer<'de>,
13181 {
13182 struct GeneratedVisitor;
13183
13184 impl serde::de::Visitor<'_> for GeneratedVisitor {
13185 type Value = GeneratedField;
13186
13187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13188 write!(formatter, "expected one of: {:?}", &FIELDS)
13189 }
13190
13191 #[allow(unused_variables)]
13192 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13193 where
13194 E: serde::de::Error,
13195 {
13196 Err(serde::de::Error::unknown_field(value, FIELDS))
13197 }
13198 }
13199 deserializer.deserialize_identifier(GeneratedVisitor)
13200 }
13201 }
13202 struct GeneratedVisitor;
13203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13204 type Value = RiseCtlResumeVersionCheckpointRequest;
13205
13206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13207 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
13208 }
13209
13210 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
13211 where
13212 V: serde::de::MapAccess<'de>,
13213 {
13214 while map_.next_key::<GeneratedField>()?.is_some() {
13215 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13216 }
13217 Ok(RiseCtlResumeVersionCheckpointRequest {
13218 })
13219 }
13220 }
13221 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
13222 }
13223}
13224impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
13225 #[allow(deprecated)]
13226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13227 where
13228 S: serde::Serializer,
13229 {
13230 use serde::ser::SerializeStruct;
13231 let len = 0;
13232 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
13233 struct_ser.end()
13234 }
13235}
13236impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
13237 #[allow(deprecated)]
13238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13239 where
13240 D: serde::Deserializer<'de>,
13241 {
13242 const FIELDS: &[&str] = &[
13243 ];
13244
13245 #[allow(clippy::enum_variant_names)]
13246 enum GeneratedField {
13247 }
13248 impl<'de> serde::Deserialize<'de> for GeneratedField {
13249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13250 where
13251 D: serde::Deserializer<'de>,
13252 {
13253 struct GeneratedVisitor;
13254
13255 impl serde::de::Visitor<'_> for GeneratedVisitor {
13256 type Value = GeneratedField;
13257
13258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13259 write!(formatter, "expected one of: {:?}", &FIELDS)
13260 }
13261
13262 #[allow(unused_variables)]
13263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13264 where
13265 E: serde::de::Error,
13266 {
13267 Err(serde::de::Error::unknown_field(value, FIELDS))
13268 }
13269 }
13270 deserializer.deserialize_identifier(GeneratedVisitor)
13271 }
13272 }
13273 struct GeneratedVisitor;
13274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13275 type Value = RiseCtlResumeVersionCheckpointResponse;
13276
13277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13278 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
13279 }
13280
13281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
13282 where
13283 V: serde::de::MapAccess<'de>,
13284 {
13285 while map_.next_key::<GeneratedField>()?.is_some() {
13286 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13287 }
13288 Ok(RiseCtlResumeVersionCheckpointResponse {
13289 })
13290 }
13291 }
13292 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
13293 }
13294}
13295impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
13296 #[allow(deprecated)]
13297 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13298 where
13299 S: serde::Serializer,
13300 {
13301 use serde::ser::SerializeStruct;
13302 let mut len = 0;
13303 if !self.compaction_group_ids.is_empty() {
13304 len += 1;
13305 }
13306 if !self.configs.is_empty() {
13307 len += 1;
13308 }
13309 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
13310 if !self.compaction_group_ids.is_empty() {
13311 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
13312 }
13313 if !self.configs.is_empty() {
13314 struct_ser.serialize_field("configs", &self.configs)?;
13315 }
13316 struct_ser.end()
13317 }
13318}
13319impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
13320 #[allow(deprecated)]
13321 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13322 where
13323 D: serde::Deserializer<'de>,
13324 {
13325 const FIELDS: &[&str] = &[
13326 "compaction_group_ids",
13327 "compactionGroupIds",
13328 "configs",
13329 ];
13330
13331 #[allow(clippy::enum_variant_names)]
13332 enum GeneratedField {
13333 CompactionGroupIds,
13334 Configs,
13335 }
13336 impl<'de> serde::Deserialize<'de> for GeneratedField {
13337 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13338 where
13339 D: serde::Deserializer<'de>,
13340 {
13341 struct GeneratedVisitor;
13342
13343 impl serde::de::Visitor<'_> for GeneratedVisitor {
13344 type Value = GeneratedField;
13345
13346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13347 write!(formatter, "expected one of: {:?}", &FIELDS)
13348 }
13349
13350 #[allow(unused_variables)]
13351 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13352 where
13353 E: serde::de::Error,
13354 {
13355 match value {
13356 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
13357 "configs" => Ok(GeneratedField::Configs),
13358 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13359 }
13360 }
13361 }
13362 deserializer.deserialize_identifier(GeneratedVisitor)
13363 }
13364 }
13365 struct GeneratedVisitor;
13366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13367 type Value = RiseCtlUpdateCompactionConfigRequest;
13368
13369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13370 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
13371 }
13372
13373 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
13374 where
13375 V: serde::de::MapAccess<'de>,
13376 {
13377 let mut compaction_group_ids__ = None;
13378 let mut configs__ = None;
13379 while let Some(k) = map_.next_key()? {
13380 match k {
13381 GeneratedField::CompactionGroupIds => {
13382 if compaction_group_ids__.is_some() {
13383 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
13384 }
13385 compaction_group_ids__ =
13386 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13387 .into_iter().map(|x| x.0).collect())
13388 ;
13389 }
13390 GeneratedField::Configs => {
13391 if configs__.is_some() {
13392 return Err(serde::de::Error::duplicate_field("configs"));
13393 }
13394 configs__ = Some(map_.next_value()?);
13395 }
13396 }
13397 }
13398 Ok(RiseCtlUpdateCompactionConfigRequest {
13399 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
13400 configs: configs__.unwrap_or_default(),
13401 })
13402 }
13403 }
13404 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
13405 }
13406}
13407impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
13408 #[allow(deprecated)]
13409 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13410 where
13411 S: serde::Serializer,
13412 {
13413 use serde::ser::SerializeStruct;
13414 let mut len = 0;
13415 if self.level != 0 {
13416 len += 1;
13417 }
13418 if !self.compression_algorithm.is_empty() {
13419 len += 1;
13420 }
13421 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
13422 if self.level != 0 {
13423 struct_ser.serialize_field("level", &self.level)?;
13424 }
13425 if !self.compression_algorithm.is_empty() {
13426 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
13427 }
13428 struct_ser.end()
13429 }
13430}
13431impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
13432 #[allow(deprecated)]
13433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13434 where
13435 D: serde::Deserializer<'de>,
13436 {
13437 const FIELDS: &[&str] = &[
13438 "level",
13439 "compression_algorithm",
13440 "compressionAlgorithm",
13441 ];
13442
13443 #[allow(clippy::enum_variant_names)]
13444 enum GeneratedField {
13445 Level,
13446 CompressionAlgorithm,
13447 }
13448 impl<'de> serde::Deserialize<'de> for GeneratedField {
13449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13450 where
13451 D: serde::Deserializer<'de>,
13452 {
13453 struct GeneratedVisitor;
13454
13455 impl serde::de::Visitor<'_> for GeneratedVisitor {
13456 type Value = GeneratedField;
13457
13458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13459 write!(formatter, "expected one of: {:?}", &FIELDS)
13460 }
13461
13462 #[allow(unused_variables)]
13463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13464 where
13465 E: serde::de::Error,
13466 {
13467 match value {
13468 "level" => Ok(GeneratedField::Level),
13469 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
13470 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13471 }
13472 }
13473 }
13474 deserializer.deserialize_identifier(GeneratedVisitor)
13475 }
13476 }
13477 struct GeneratedVisitor;
13478 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13479 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
13480
13481 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13482 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
13483 }
13484
13485 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
13486 where
13487 V: serde::de::MapAccess<'de>,
13488 {
13489 let mut level__ = None;
13490 let mut compression_algorithm__ = None;
13491 while let Some(k) = map_.next_key()? {
13492 match k {
13493 GeneratedField::Level => {
13494 if level__.is_some() {
13495 return Err(serde::de::Error::duplicate_field("level"));
13496 }
13497 level__ =
13498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13499 ;
13500 }
13501 GeneratedField::CompressionAlgorithm => {
13502 if compression_algorithm__.is_some() {
13503 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13504 }
13505 compression_algorithm__ = Some(map_.next_value()?);
13506 }
13507 }
13508 }
13509 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
13510 level: level__.unwrap_or_default(),
13511 compression_algorithm: compression_algorithm__.unwrap_or_default(),
13512 })
13513 }
13514 }
13515 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
13516 }
13517}
13518impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
13519 #[allow(deprecated)]
13520 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13521 where
13522 S: serde::Serializer,
13523 {
13524 use serde::ser::SerializeStruct;
13525 let mut len = 0;
13526 if self.mutable_config.is_some() {
13527 len += 1;
13528 }
13529 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
13530 if let Some(v) = self.mutable_config.as_ref() {
13531 match v {
13532 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
13533 #[allow(clippy::needless_borrow)]
13534 #[allow(clippy::needless_borrows_for_generic_args)]
13535 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
13536 }
13537 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
13538 #[allow(clippy::needless_borrow)]
13539 #[allow(clippy::needless_borrows_for_generic_args)]
13540 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
13541 }
13542 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
13543 #[allow(clippy::needless_borrow)]
13544 #[allow(clippy::needless_borrows_for_generic_args)]
13545 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
13546 }
13547 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
13548 #[allow(clippy::needless_borrow)]
13549 #[allow(clippy::needless_borrows_for_generic_args)]
13550 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
13551 }
13552 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
13553 #[allow(clippy::needless_borrow)]
13554 #[allow(clippy::needless_borrows_for_generic_args)]
13555 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
13556 }
13557 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
13558 #[allow(clippy::needless_borrow)]
13559 #[allow(clippy::needless_borrows_for_generic_args)]
13560 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
13561 }
13562 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
13563 struct_ser.serialize_field("compactionFilterMask", v)?;
13564 }
13565 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
13566 struct_ser.serialize_field("maxSubCompaction", v)?;
13567 }
13568 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
13569 #[allow(clippy::needless_borrow)]
13570 #[allow(clippy::needless_borrows_for_generic_args)]
13571 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
13572 }
13573 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
13574 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
13575 }
13576 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
13577 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
13578 }
13579 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
13580 #[allow(clippy::needless_borrow)]
13581 #[allow(clippy::needless_borrows_for_generic_args)]
13582 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
13583 }
13584 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
13585 #[allow(clippy::needless_borrow)]
13586 #[allow(clippy::needless_borrows_for_generic_args)]
13587 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
13588 }
13589 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
13590 struct_ser.serialize_field("enableEmergencyPicker", v)?;
13591 }
13592 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
13593 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
13594 }
13595 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
13596 struct_ser.serialize_field("compressionAlgorithm", v)?;
13597 }
13598 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
13599 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
13600 }
13601 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
13602 #[allow(clippy::needless_borrow)]
13603 #[allow(clippy::needless_borrows_for_generic_args)]
13604 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
13605 }
13606 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
13607 struct_ser.serialize_field("splitWeightByVnode", v)?;
13608 }
13609 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
13610 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
13611 }
13612 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
13613 #[allow(clippy::needless_borrow)]
13614 #[allow(clippy::needless_borrows_for_generic_args)]
13615 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
13616 }
13617 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
13618 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
13619 }
13620 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
13621 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
13622 }
13623 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
13624 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
13625 }
13626 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
13627 #[allow(clippy::needless_borrow)]
13628 #[allow(clippy::needless_borrows_for_generic_args)]
13629 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
13630 }
13631 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
13632 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
13633 }
13634 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
13635 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
13636 }
13637 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::VnodeAlignedLevelSizeThreshold(v) => {
13638 #[allow(clippy::needless_borrow)]
13639 #[allow(clippy::needless_borrows_for_generic_args)]
13640 struct_ser.serialize_field("vnodeAlignedLevelSizeThreshold", ToString::to_string(&v).as_str())?;
13641 }
13642 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxKvCountForXor16(v) => {
13643 #[allow(clippy::needless_borrow)]
13644 #[allow(clippy::needless_borrows_for_generic_args)]
13645 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
13646 }
13647 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxVnodeKeyRangeBytes(v) => {
13648 #[allow(clippy::needless_borrow)]
13649 #[allow(clippy::needless_borrows_for_generic_args)]
13650 struct_ser.serialize_field("maxVnodeKeyRangeBytes", ToString::to_string(&v).as_str())?;
13651 }
13652 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::ResetCompressionAlgorithm(v) => {
13653 struct_ser.serialize_field("resetCompressionAlgorithm", v)?;
13654 }
13655 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstableFilterKind(v) => {
13656 struct_ser.serialize_field("sstableFilterKind", v)?;
13657 }
13658 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstableFilterLayout(v) => {
13659 struct_ser.serialize_field("sstableFilterLayout", v)?;
13660 }
13661 }
13662 }
13663 struct_ser.end()
13664 }
13665}
13666impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
13667 #[allow(deprecated)]
13668 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13669 where
13670 D: serde::Deserializer<'de>,
13671 {
13672 const FIELDS: &[&str] = &[
13673 "max_bytes_for_level_base",
13674 "maxBytesForLevelBase",
13675 "max_bytes_for_level_multiplier",
13676 "maxBytesForLevelMultiplier",
13677 "max_compaction_bytes",
13678 "maxCompactionBytes",
13679 "sub_level_max_compaction_bytes",
13680 "subLevelMaxCompactionBytes",
13681 "level0_tier_compact_file_number",
13682 "level0TierCompactFileNumber",
13683 "target_file_size_base",
13684 "targetFileSizeBase",
13685 "compaction_filter_mask",
13686 "compactionFilterMask",
13687 "max_sub_compaction",
13688 "maxSubCompaction",
13689 "level0_stop_write_threshold_sub_level_number",
13690 "level0StopWriteThresholdSubLevelNumber",
13691 "level0_sub_level_compact_level_count",
13692 "level0SubLevelCompactLevelCount",
13693 "level0_overlapping_sub_level_compact_level_count",
13694 "level0OverlappingSubLevelCompactLevelCount",
13695 "max_space_reclaim_bytes",
13696 "maxSpaceReclaimBytes",
13697 "level0_max_compact_file_number",
13698 "level0MaxCompactFileNumber",
13699 "enable_emergency_picker",
13700 "enableEmergencyPicker",
13701 "tombstone_reclaim_ratio",
13702 "tombstoneReclaimRatio",
13703 "compression_algorithm",
13704 "compressionAlgorithm",
13705 "max_l0_compact_level_count",
13706 "maxL0CompactLevelCount",
13707 "sst_allowed_trivial_move_min_size",
13708 "sstAllowedTrivialMoveMinSize",
13709 "split_weight_by_vnode",
13710 "splitWeightByVnode",
13711 "disable_auto_group_scheduling",
13712 "disableAutoGroupScheduling",
13713 "max_overlapping_level_size",
13714 "maxOverlappingLevelSize",
13715 "emergency_level0_sst_file_count",
13716 "emergencyLevel0SstFileCount",
13717 "emergency_level0_sub_level_partition",
13718 "emergencyLevel0SubLevelPartition",
13719 "level0_stop_write_threshold_max_sst_count",
13720 "level0StopWriteThresholdMaxSstCount",
13721 "level0_stop_write_threshold_max_size",
13722 "level0StopWriteThresholdMaxSize",
13723 "sst_allowed_trivial_move_max_count",
13724 "sstAllowedTrivialMoveMaxCount",
13725 "enable_optimize_l0_interval_selection",
13726 "enableOptimizeL0IntervalSelection",
13727 "vnode_aligned_level_size_threshold",
13728 "vnodeAlignedLevelSizeThreshold",
13729 "max_kv_count_for_xor16",
13730 "maxKvCountForXor16",
13731 "max_vnode_key_range_bytes",
13732 "maxVnodeKeyRangeBytes",
13733 "reset_compression_algorithm",
13734 "resetCompressionAlgorithm",
13735 "sstable_filter_kind",
13736 "sstableFilterKind",
13737 "sstable_filter_layout",
13738 "sstableFilterLayout",
13739 ];
13740
13741 #[allow(clippy::enum_variant_names)]
13742 enum GeneratedField {
13743 MaxBytesForLevelBase,
13744 MaxBytesForLevelMultiplier,
13745 MaxCompactionBytes,
13746 SubLevelMaxCompactionBytes,
13747 Level0TierCompactFileNumber,
13748 TargetFileSizeBase,
13749 CompactionFilterMask,
13750 MaxSubCompaction,
13751 Level0StopWriteThresholdSubLevelNumber,
13752 Level0SubLevelCompactLevelCount,
13753 Level0OverlappingSubLevelCompactLevelCount,
13754 MaxSpaceReclaimBytes,
13755 Level0MaxCompactFileNumber,
13756 EnableEmergencyPicker,
13757 TombstoneReclaimRatio,
13758 CompressionAlgorithm,
13759 MaxL0CompactLevelCount,
13760 SstAllowedTrivialMoveMinSize,
13761 SplitWeightByVnode,
13762 DisableAutoGroupScheduling,
13763 MaxOverlappingLevelSize,
13764 EmergencyLevel0SstFileCount,
13765 EmergencyLevel0SubLevelPartition,
13766 Level0StopWriteThresholdMaxSstCount,
13767 Level0StopWriteThresholdMaxSize,
13768 SstAllowedTrivialMoveMaxCount,
13769 EnableOptimizeL0IntervalSelection,
13770 VnodeAlignedLevelSizeThreshold,
13771 MaxKvCountForXor16,
13772 MaxVnodeKeyRangeBytes,
13773 ResetCompressionAlgorithm,
13774 SstableFilterKind,
13775 SstableFilterLayout,
13776 }
13777 impl<'de> serde::Deserialize<'de> for GeneratedField {
13778 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13779 where
13780 D: serde::Deserializer<'de>,
13781 {
13782 struct GeneratedVisitor;
13783
13784 impl serde::de::Visitor<'_> for GeneratedVisitor {
13785 type Value = GeneratedField;
13786
13787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13788 write!(formatter, "expected one of: {:?}", &FIELDS)
13789 }
13790
13791 #[allow(unused_variables)]
13792 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13793 where
13794 E: serde::de::Error,
13795 {
13796 match value {
13797 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
13798 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
13799 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
13800 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
13801 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
13802 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
13803 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
13804 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
13805 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
13806 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
13807 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
13808 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
13809 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
13810 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
13811 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
13812 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
13813 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
13814 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
13815 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
13816 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
13817 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
13818 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
13819 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
13820 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
13821 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
13822 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
13823 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
13824 "vnodeAlignedLevelSizeThreshold" | "vnode_aligned_level_size_threshold" => Ok(GeneratedField::VnodeAlignedLevelSizeThreshold),
13825 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
13826 "maxVnodeKeyRangeBytes" | "max_vnode_key_range_bytes" => Ok(GeneratedField::MaxVnodeKeyRangeBytes),
13827 "resetCompressionAlgorithm" | "reset_compression_algorithm" => Ok(GeneratedField::ResetCompressionAlgorithm),
13828 "sstableFilterKind" | "sstable_filter_kind" => Ok(GeneratedField::SstableFilterKind),
13829 "sstableFilterLayout" | "sstable_filter_layout" => Ok(GeneratedField::SstableFilterLayout),
13830 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13831 }
13832 }
13833 }
13834 deserializer.deserialize_identifier(GeneratedVisitor)
13835 }
13836 }
13837 struct GeneratedVisitor;
13838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13839 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
13840
13841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13842 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
13843 }
13844
13845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
13846 where
13847 V: serde::de::MapAccess<'de>,
13848 {
13849 let mut mutable_config__ = None;
13850 while let Some(k) = map_.next_key()? {
13851 match k {
13852 GeneratedField::MaxBytesForLevelBase => {
13853 if mutable_config__.is_some() {
13854 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
13855 }
13856 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));
13857 }
13858 GeneratedField::MaxBytesForLevelMultiplier => {
13859 if mutable_config__.is_some() {
13860 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
13861 }
13862 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));
13863 }
13864 GeneratedField::MaxCompactionBytes => {
13865 if mutable_config__.is_some() {
13866 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
13867 }
13868 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));
13869 }
13870 GeneratedField::SubLevelMaxCompactionBytes => {
13871 if mutable_config__.is_some() {
13872 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
13873 }
13874 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));
13875 }
13876 GeneratedField::Level0TierCompactFileNumber => {
13877 if mutable_config__.is_some() {
13878 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
13879 }
13880 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));
13881 }
13882 GeneratedField::TargetFileSizeBase => {
13883 if mutable_config__.is_some() {
13884 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
13885 }
13886 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));
13887 }
13888 GeneratedField::CompactionFilterMask => {
13889 if mutable_config__.is_some() {
13890 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
13891 }
13892 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));
13893 }
13894 GeneratedField::MaxSubCompaction => {
13895 if mutable_config__.is_some() {
13896 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
13897 }
13898 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));
13899 }
13900 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
13901 if mutable_config__.is_some() {
13902 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
13903 }
13904 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));
13905 }
13906 GeneratedField::Level0SubLevelCompactLevelCount => {
13907 if mutable_config__.is_some() {
13908 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
13909 }
13910 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));
13911 }
13912 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
13913 if mutable_config__.is_some() {
13914 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
13915 }
13916 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));
13917 }
13918 GeneratedField::MaxSpaceReclaimBytes => {
13919 if mutable_config__.is_some() {
13920 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
13921 }
13922 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));
13923 }
13924 GeneratedField::Level0MaxCompactFileNumber => {
13925 if mutable_config__.is_some() {
13926 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
13927 }
13928 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));
13929 }
13930 GeneratedField::EnableEmergencyPicker => {
13931 if mutable_config__.is_some() {
13932 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
13933 }
13934 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
13935 }
13936 GeneratedField::TombstoneReclaimRatio => {
13937 if mutable_config__.is_some() {
13938 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
13939 }
13940 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));
13941 }
13942 GeneratedField::CompressionAlgorithm => {
13943 if mutable_config__.is_some() {
13944 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13945 }
13946 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
13947;
13948 }
13949 GeneratedField::MaxL0CompactLevelCount => {
13950 if mutable_config__.is_some() {
13951 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
13952 }
13953 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));
13954 }
13955 GeneratedField::SstAllowedTrivialMoveMinSize => {
13956 if mutable_config__.is_some() {
13957 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
13958 }
13959 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));
13960 }
13961 GeneratedField::SplitWeightByVnode => {
13962 if mutable_config__.is_some() {
13963 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
13964 }
13965 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));
13966 }
13967 GeneratedField::DisableAutoGroupScheduling => {
13968 if mutable_config__.is_some() {
13969 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
13970 }
13971 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
13972 }
13973 GeneratedField::MaxOverlappingLevelSize => {
13974 if mutable_config__.is_some() {
13975 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
13976 }
13977 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));
13978 }
13979 GeneratedField::EmergencyLevel0SstFileCount => {
13980 if mutable_config__.is_some() {
13981 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
13982 }
13983 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));
13984 }
13985 GeneratedField::EmergencyLevel0SubLevelPartition => {
13986 if mutable_config__.is_some() {
13987 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
13988 }
13989 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));
13990 }
13991 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
13992 if mutable_config__.is_some() {
13993 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
13994 }
13995 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));
13996 }
13997 GeneratedField::Level0StopWriteThresholdMaxSize => {
13998 if mutable_config__.is_some() {
13999 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
14000 }
14001 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));
14002 }
14003 GeneratedField::SstAllowedTrivialMoveMaxCount => {
14004 if mutable_config__.is_some() {
14005 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
14006 }
14007 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));
14008 }
14009 GeneratedField::EnableOptimizeL0IntervalSelection => {
14010 if mutable_config__.is_some() {
14011 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
14012 }
14013 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
14014 }
14015 GeneratedField::VnodeAlignedLevelSizeThreshold => {
14016 if mutable_config__.is_some() {
14017 return Err(serde::de::Error::duplicate_field("vnodeAlignedLevelSizeThreshold"));
14018 }
14019 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::VnodeAlignedLevelSizeThreshold(x.0));
14020 }
14021 GeneratedField::MaxKvCountForXor16 => {
14022 if mutable_config__.is_some() {
14023 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
14024 }
14025 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxKvCountForXor16(x.0));
14026 }
14027 GeneratedField::MaxVnodeKeyRangeBytes => {
14028 if mutable_config__.is_some() {
14029 return Err(serde::de::Error::duplicate_field("maxVnodeKeyRangeBytes"));
14030 }
14031 mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxVnodeKeyRangeBytes(x.0));
14032 }
14033 GeneratedField::ResetCompressionAlgorithm => {
14034 if mutable_config__.is_some() {
14035 return Err(serde::de::Error::duplicate_field("resetCompressionAlgorithm"));
14036 }
14037 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::ResetCompressionAlgorithm);
14038 }
14039 GeneratedField::SstableFilterKind => {
14040 if mutable_config__.is_some() {
14041 return Err(serde::de::Error::duplicate_field("sstableFilterKind"));
14042 }
14043 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstableFilterKind)
14044;
14045 }
14046 GeneratedField::SstableFilterLayout => {
14047 if mutable_config__.is_some() {
14048 return Err(serde::de::Error::duplicate_field("sstableFilterLayout"));
14049 }
14050 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstableFilterLayout)
14051;
14052 }
14053 }
14054 }
14055 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
14056 mutable_config: mutable_config__,
14057 })
14058 }
14059 }
14060 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
14061 }
14062}
14063impl serde::Serialize for rise_ctl_update_compaction_config_request::SstableFilterKind {
14064 #[allow(deprecated)]
14065 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14066 where
14067 S: serde::Serializer,
14068 {
14069 use serde::ser::SerializeStruct;
14070 let mut len = 0;
14071 if self.level != 0 {
14072 len += 1;
14073 }
14074 if !self.filter_kind.is_empty() {
14075 len += 1;
14076 }
14077 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterKind", len)?;
14078 if self.level != 0 {
14079 struct_ser.serialize_field("level", &self.level)?;
14080 }
14081 if !self.filter_kind.is_empty() {
14082 struct_ser.serialize_field("filterKind", &self.filter_kind)?;
14083 }
14084 struct_ser.end()
14085 }
14086}
14087impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::SstableFilterKind {
14088 #[allow(deprecated)]
14089 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14090 where
14091 D: serde::Deserializer<'de>,
14092 {
14093 const FIELDS: &[&str] = &[
14094 "level",
14095 "filter_kind",
14096 "filterKind",
14097 ];
14098
14099 #[allow(clippy::enum_variant_names)]
14100 enum GeneratedField {
14101 Level,
14102 FilterKind,
14103 }
14104 impl<'de> serde::Deserialize<'de> for GeneratedField {
14105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14106 where
14107 D: serde::Deserializer<'de>,
14108 {
14109 struct GeneratedVisitor;
14110
14111 impl serde::de::Visitor<'_> for GeneratedVisitor {
14112 type Value = GeneratedField;
14113
14114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14115 write!(formatter, "expected one of: {:?}", &FIELDS)
14116 }
14117
14118 #[allow(unused_variables)]
14119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14120 where
14121 E: serde::de::Error,
14122 {
14123 match value {
14124 "level" => Ok(GeneratedField::Level),
14125 "filterKind" | "filter_kind" => Ok(GeneratedField::FilterKind),
14126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14127 }
14128 }
14129 }
14130 deserializer.deserialize_identifier(GeneratedVisitor)
14131 }
14132 }
14133 struct GeneratedVisitor;
14134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14135 type Value = rise_ctl_update_compaction_config_request::SstableFilterKind;
14136
14137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14138 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterKind")
14139 }
14140
14141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::SstableFilterKind, V::Error>
14142 where
14143 V: serde::de::MapAccess<'de>,
14144 {
14145 let mut level__ = None;
14146 let mut filter_kind__ = None;
14147 while let Some(k) = map_.next_key()? {
14148 match k {
14149 GeneratedField::Level => {
14150 if level__.is_some() {
14151 return Err(serde::de::Error::duplicate_field("level"));
14152 }
14153 level__ =
14154 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14155 ;
14156 }
14157 GeneratedField::FilterKind => {
14158 if filter_kind__.is_some() {
14159 return Err(serde::de::Error::duplicate_field("filterKind"));
14160 }
14161 filter_kind__ = Some(map_.next_value()?);
14162 }
14163 }
14164 }
14165 Ok(rise_ctl_update_compaction_config_request::SstableFilterKind {
14166 level: level__.unwrap_or_default(),
14167 filter_kind: filter_kind__.unwrap_or_default(),
14168 })
14169 }
14170 }
14171 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterKind", FIELDS, GeneratedVisitor)
14172 }
14173}
14174impl serde::Serialize for rise_ctl_update_compaction_config_request::SstableFilterLayout {
14175 #[allow(deprecated)]
14176 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14177 where
14178 S: serde::Serializer,
14179 {
14180 use serde::ser::SerializeStruct;
14181 let mut len = 0;
14182 if self.level != 0 {
14183 len += 1;
14184 }
14185 if !self.layout.is_empty() {
14186 len += 1;
14187 }
14188 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterLayout", len)?;
14189 if self.level != 0 {
14190 struct_ser.serialize_field("level", &self.level)?;
14191 }
14192 if !self.layout.is_empty() {
14193 struct_ser.serialize_field("layout", &self.layout)?;
14194 }
14195 struct_ser.end()
14196 }
14197}
14198impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::SstableFilterLayout {
14199 #[allow(deprecated)]
14200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14201 where
14202 D: serde::Deserializer<'de>,
14203 {
14204 const FIELDS: &[&str] = &[
14205 "level",
14206 "layout",
14207 ];
14208
14209 #[allow(clippy::enum_variant_names)]
14210 enum GeneratedField {
14211 Level,
14212 Layout,
14213 }
14214 impl<'de> serde::Deserialize<'de> for GeneratedField {
14215 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14216 where
14217 D: serde::Deserializer<'de>,
14218 {
14219 struct GeneratedVisitor;
14220
14221 impl serde::de::Visitor<'_> for GeneratedVisitor {
14222 type Value = GeneratedField;
14223
14224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14225 write!(formatter, "expected one of: {:?}", &FIELDS)
14226 }
14227
14228 #[allow(unused_variables)]
14229 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14230 where
14231 E: serde::de::Error,
14232 {
14233 match value {
14234 "level" => Ok(GeneratedField::Level),
14235 "layout" => Ok(GeneratedField::Layout),
14236 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14237 }
14238 }
14239 }
14240 deserializer.deserialize_identifier(GeneratedVisitor)
14241 }
14242 }
14243 struct GeneratedVisitor;
14244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14245 type Value = rise_ctl_update_compaction_config_request::SstableFilterLayout;
14246
14247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14248 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterLayout")
14249 }
14250
14251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::SstableFilterLayout, V::Error>
14252 where
14253 V: serde::de::MapAccess<'de>,
14254 {
14255 let mut level__ = None;
14256 let mut layout__ = None;
14257 while let Some(k) = map_.next_key()? {
14258 match k {
14259 GeneratedField::Level => {
14260 if level__.is_some() {
14261 return Err(serde::de::Error::duplicate_field("level"));
14262 }
14263 level__ =
14264 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14265 ;
14266 }
14267 GeneratedField::Layout => {
14268 if layout__.is_some() {
14269 return Err(serde::de::Error::duplicate_field("layout"));
14270 }
14271 layout__ = Some(map_.next_value()?);
14272 }
14273 }
14274 }
14275 Ok(rise_ctl_update_compaction_config_request::SstableFilterLayout {
14276 level: level__.unwrap_or_default(),
14277 layout: layout__.unwrap_or_default(),
14278 })
14279 }
14280 }
14281 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.SstableFilterLayout", FIELDS, GeneratedVisitor)
14282 }
14283}
14284impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
14285 #[allow(deprecated)]
14286 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14287 where
14288 S: serde::Serializer,
14289 {
14290 use serde::ser::SerializeStruct;
14291 let mut len = 0;
14292 if self.status.is_some() {
14293 len += 1;
14294 }
14295 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
14296 if let Some(v) = self.status.as_ref() {
14297 struct_ser.serialize_field("status", v)?;
14298 }
14299 struct_ser.end()
14300 }
14301}
14302impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
14303 #[allow(deprecated)]
14304 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14305 where
14306 D: serde::Deserializer<'de>,
14307 {
14308 const FIELDS: &[&str] = &[
14309 "status",
14310 ];
14311
14312 #[allow(clippy::enum_variant_names)]
14313 enum GeneratedField {
14314 Status,
14315 }
14316 impl<'de> serde::Deserialize<'de> for GeneratedField {
14317 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14318 where
14319 D: serde::Deserializer<'de>,
14320 {
14321 struct GeneratedVisitor;
14322
14323 impl serde::de::Visitor<'_> for GeneratedVisitor {
14324 type Value = GeneratedField;
14325
14326 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14327 write!(formatter, "expected one of: {:?}", &FIELDS)
14328 }
14329
14330 #[allow(unused_variables)]
14331 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14332 where
14333 E: serde::de::Error,
14334 {
14335 match value {
14336 "status" => Ok(GeneratedField::Status),
14337 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14338 }
14339 }
14340 }
14341 deserializer.deserialize_identifier(GeneratedVisitor)
14342 }
14343 }
14344 struct GeneratedVisitor;
14345 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14346 type Value = RiseCtlUpdateCompactionConfigResponse;
14347
14348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14349 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
14350 }
14351
14352 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
14353 where
14354 V: serde::de::MapAccess<'de>,
14355 {
14356 let mut status__ = None;
14357 while let Some(k) = map_.next_key()? {
14358 match k {
14359 GeneratedField::Status => {
14360 if status__.is_some() {
14361 return Err(serde::de::Error::duplicate_field("status"));
14362 }
14363 status__ = map_.next_value()?;
14364 }
14365 }
14366 }
14367 Ok(RiseCtlUpdateCompactionConfigResponse {
14368 status: status__,
14369 })
14370 }
14371 }
14372 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
14373 }
14374}
14375impl serde::Serialize for SplitCompactionGroupRequest {
14376 #[allow(deprecated)]
14377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14378 where
14379 S: serde::Serializer,
14380 {
14381 use serde::ser::SerializeStruct;
14382 let mut len = 0;
14383 if self.group_id != 0 {
14384 len += 1;
14385 }
14386 if !self.table_ids.is_empty() {
14387 len += 1;
14388 }
14389 if self.partition_vnode_count != 0 {
14390 len += 1;
14391 }
14392 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
14393 if self.group_id != 0 {
14394 #[allow(clippy::needless_borrow)]
14395 #[allow(clippy::needless_borrows_for_generic_args)]
14396 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
14397 }
14398 if !self.table_ids.is_empty() {
14399 struct_ser.serialize_field("tableIds", &self.table_ids)?;
14400 }
14401 if self.partition_vnode_count != 0 {
14402 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
14403 }
14404 struct_ser.end()
14405 }
14406}
14407impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
14408 #[allow(deprecated)]
14409 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14410 where
14411 D: serde::Deserializer<'de>,
14412 {
14413 const FIELDS: &[&str] = &[
14414 "group_id",
14415 "groupId",
14416 "table_ids",
14417 "tableIds",
14418 "partition_vnode_count",
14419 "partitionVnodeCount",
14420 ];
14421
14422 #[allow(clippy::enum_variant_names)]
14423 enum GeneratedField {
14424 GroupId,
14425 TableIds,
14426 PartitionVnodeCount,
14427 }
14428 impl<'de> serde::Deserialize<'de> for GeneratedField {
14429 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14430 where
14431 D: serde::Deserializer<'de>,
14432 {
14433 struct GeneratedVisitor;
14434
14435 impl serde::de::Visitor<'_> for GeneratedVisitor {
14436 type Value = GeneratedField;
14437
14438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14439 write!(formatter, "expected one of: {:?}", &FIELDS)
14440 }
14441
14442 #[allow(unused_variables)]
14443 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14444 where
14445 E: serde::de::Error,
14446 {
14447 match value {
14448 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
14449 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
14450 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
14451 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14452 }
14453 }
14454 }
14455 deserializer.deserialize_identifier(GeneratedVisitor)
14456 }
14457 }
14458 struct GeneratedVisitor;
14459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14460 type Value = SplitCompactionGroupRequest;
14461
14462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14463 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
14464 }
14465
14466 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
14467 where
14468 V: serde::de::MapAccess<'de>,
14469 {
14470 let mut group_id__ = None;
14471 let mut table_ids__ = None;
14472 let mut partition_vnode_count__ = None;
14473 while let Some(k) = map_.next_key()? {
14474 match k {
14475 GeneratedField::GroupId => {
14476 if group_id__.is_some() {
14477 return Err(serde::de::Error::duplicate_field("groupId"));
14478 }
14479 group_id__ =
14480 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14481 ;
14482 }
14483 GeneratedField::TableIds => {
14484 if table_ids__.is_some() {
14485 return Err(serde::de::Error::duplicate_field("tableIds"));
14486 }
14487 table_ids__ =
14488 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14489 .into_iter().map(|x| x.0).collect())
14490 ;
14491 }
14492 GeneratedField::PartitionVnodeCount => {
14493 if partition_vnode_count__.is_some() {
14494 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
14495 }
14496 partition_vnode_count__ =
14497 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14498 ;
14499 }
14500 }
14501 }
14502 Ok(SplitCompactionGroupRequest {
14503 group_id: group_id__.unwrap_or_default(),
14504 table_ids: table_ids__.unwrap_or_default(),
14505 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
14506 })
14507 }
14508 }
14509 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
14510 }
14511}
14512impl serde::Serialize for SplitCompactionGroupResponse {
14513 #[allow(deprecated)]
14514 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14515 where
14516 S: serde::Serializer,
14517 {
14518 use serde::ser::SerializeStruct;
14519 let mut len = 0;
14520 if self.new_group_id != 0 {
14521 len += 1;
14522 }
14523 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
14524 if self.new_group_id != 0 {
14525 #[allow(clippy::needless_borrow)]
14526 #[allow(clippy::needless_borrows_for_generic_args)]
14527 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
14528 }
14529 struct_ser.end()
14530 }
14531}
14532impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
14533 #[allow(deprecated)]
14534 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14535 where
14536 D: serde::Deserializer<'de>,
14537 {
14538 const FIELDS: &[&str] = &[
14539 "new_group_id",
14540 "newGroupId",
14541 ];
14542
14543 #[allow(clippy::enum_variant_names)]
14544 enum GeneratedField {
14545 NewGroupId,
14546 }
14547 impl<'de> serde::Deserialize<'de> for GeneratedField {
14548 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14549 where
14550 D: serde::Deserializer<'de>,
14551 {
14552 struct GeneratedVisitor;
14553
14554 impl serde::de::Visitor<'_> for GeneratedVisitor {
14555 type Value = GeneratedField;
14556
14557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14558 write!(formatter, "expected one of: {:?}", &FIELDS)
14559 }
14560
14561 #[allow(unused_variables)]
14562 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14563 where
14564 E: serde::de::Error,
14565 {
14566 match value {
14567 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
14568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14569 }
14570 }
14571 }
14572 deserializer.deserialize_identifier(GeneratedVisitor)
14573 }
14574 }
14575 struct GeneratedVisitor;
14576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14577 type Value = SplitCompactionGroupResponse;
14578
14579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14580 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
14581 }
14582
14583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
14584 where
14585 V: serde::de::MapAccess<'de>,
14586 {
14587 let mut new_group_id__ = None;
14588 while let Some(k) = map_.next_key()? {
14589 match k {
14590 GeneratedField::NewGroupId => {
14591 if new_group_id__.is_some() {
14592 return Err(serde::de::Error::duplicate_field("newGroupId"));
14593 }
14594 new_group_id__ =
14595 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14596 ;
14597 }
14598 }
14599 }
14600 Ok(SplitCompactionGroupResponse {
14601 new_group_id: new_group_id__.unwrap_or_default(),
14602 })
14603 }
14604 }
14605 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
14606 }
14607}
14608impl serde::Serialize for SstableFilterLayout {
14609 #[allow(deprecated)]
14610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14611 where
14612 S: serde::Serializer,
14613 {
14614 let variant = match self {
14615 Self::Unspecified => "SSTABLE_FILTER_LAYOUT_UNSPECIFIED",
14616 Self::Auto => "SSTABLE_FILTER_LAYOUT_AUTO",
14617 Self::Plain => "SSTABLE_FILTER_LAYOUT_PLAIN",
14618 Self::Blocked => "SSTABLE_FILTER_LAYOUT_BLOCKED",
14619 };
14620 serializer.serialize_str(variant)
14621 }
14622}
14623impl<'de> serde::Deserialize<'de> for SstableFilterLayout {
14624 #[allow(deprecated)]
14625 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14626 where
14627 D: serde::Deserializer<'de>,
14628 {
14629 const FIELDS: &[&str] = &[
14630 "SSTABLE_FILTER_LAYOUT_UNSPECIFIED",
14631 "SSTABLE_FILTER_LAYOUT_AUTO",
14632 "SSTABLE_FILTER_LAYOUT_PLAIN",
14633 "SSTABLE_FILTER_LAYOUT_BLOCKED",
14634 ];
14635
14636 struct GeneratedVisitor;
14637
14638 impl serde::de::Visitor<'_> for GeneratedVisitor {
14639 type Value = SstableFilterLayout;
14640
14641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14642 write!(formatter, "expected one of: {:?}", &FIELDS)
14643 }
14644
14645 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14646 where
14647 E: serde::de::Error,
14648 {
14649 i32::try_from(v)
14650 .ok()
14651 .and_then(|x| x.try_into().ok())
14652 .ok_or_else(|| {
14653 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14654 })
14655 }
14656
14657 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14658 where
14659 E: serde::de::Error,
14660 {
14661 i32::try_from(v)
14662 .ok()
14663 .and_then(|x| x.try_into().ok())
14664 .ok_or_else(|| {
14665 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14666 })
14667 }
14668
14669 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14670 where
14671 E: serde::de::Error,
14672 {
14673 match value {
14674 "SSTABLE_FILTER_LAYOUT_UNSPECIFIED" => Ok(SstableFilterLayout::Unspecified),
14675 "SSTABLE_FILTER_LAYOUT_AUTO" => Ok(SstableFilterLayout::Auto),
14676 "SSTABLE_FILTER_LAYOUT_PLAIN" => Ok(SstableFilterLayout::Plain),
14677 "SSTABLE_FILTER_LAYOUT_BLOCKED" => Ok(SstableFilterLayout::Blocked),
14678 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14679 }
14680 }
14681 }
14682 deserializer.deserialize_any(GeneratedVisitor)
14683 }
14684}
14685impl serde::Serialize for SstableFilterType {
14686 #[allow(deprecated)]
14687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14688 where
14689 S: serde::Serializer,
14690 {
14691 let variant = match self {
14692 Self::SstableFilterUnspecified => "SSTABLE_FILTER_UNSPECIFIED",
14693 Self::SstableFilterNone => "SSTABLE_FILTER_NONE",
14694 Self::SstableFilterXor8 => "SSTABLE_FILTER_XOR8",
14695 Self::SstableFilterXor16 => "SSTABLE_FILTER_XOR16",
14696 };
14697 serializer.serialize_str(variant)
14698 }
14699}
14700impl<'de> serde::Deserialize<'de> for SstableFilterType {
14701 #[allow(deprecated)]
14702 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14703 where
14704 D: serde::Deserializer<'de>,
14705 {
14706 const FIELDS: &[&str] = &[
14707 "SSTABLE_FILTER_UNSPECIFIED",
14708 "SSTABLE_FILTER_NONE",
14709 "SSTABLE_FILTER_XOR8",
14710 "SSTABLE_FILTER_XOR16",
14711 ];
14712
14713 struct GeneratedVisitor;
14714
14715 impl serde::de::Visitor<'_> for GeneratedVisitor {
14716 type Value = SstableFilterType;
14717
14718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14719 write!(formatter, "expected one of: {:?}", &FIELDS)
14720 }
14721
14722 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14723 where
14724 E: serde::de::Error,
14725 {
14726 i32::try_from(v)
14727 .ok()
14728 .and_then(|x| x.try_into().ok())
14729 .ok_or_else(|| {
14730 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14731 })
14732 }
14733
14734 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14735 where
14736 E: serde::de::Error,
14737 {
14738 i32::try_from(v)
14739 .ok()
14740 .and_then(|x| x.try_into().ok())
14741 .ok_or_else(|| {
14742 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14743 })
14744 }
14745
14746 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14747 where
14748 E: serde::de::Error,
14749 {
14750 match value {
14751 "SSTABLE_FILTER_UNSPECIFIED" => Ok(SstableFilterType::SstableFilterUnspecified),
14752 "SSTABLE_FILTER_NONE" => Ok(SstableFilterType::SstableFilterNone),
14753 "SSTABLE_FILTER_XOR8" => Ok(SstableFilterType::SstableFilterXor8),
14754 "SSTABLE_FILTER_XOR16" => Ok(SstableFilterType::SstableFilterXor16),
14755 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14756 }
14757 }
14758 }
14759 deserializer.deserialize_any(GeneratedVisitor)
14760 }
14761}
14762impl serde::Serialize for SstableInfo {
14763 #[allow(deprecated)]
14764 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14765 where
14766 S: serde::Serializer,
14767 {
14768 use serde::ser::SerializeStruct;
14769 let mut len = 0;
14770 if self.object_id != 0 {
14771 len += 1;
14772 }
14773 if self.sst_id != 0 {
14774 len += 1;
14775 }
14776 if self.key_range.is_some() {
14777 len += 1;
14778 }
14779 if self.file_size != 0 {
14780 len += 1;
14781 }
14782 if !self.table_ids.is_empty() {
14783 len += 1;
14784 }
14785 if self.meta_offset != 0 {
14786 len += 1;
14787 }
14788 if self.stale_key_count != 0 {
14789 len += 1;
14790 }
14791 if self.total_key_count != 0 {
14792 len += 1;
14793 }
14794 if self.min_epoch != 0 {
14795 len += 1;
14796 }
14797 if self.max_epoch != 0 {
14798 len += 1;
14799 }
14800 if self.uncompressed_file_size != 0 {
14801 len += 1;
14802 }
14803 if self.range_tombstone_count != 0 {
14804 len += 1;
14805 }
14806 if self.bloom_filter_kind != 0 {
14807 len += 1;
14808 }
14809 if self.sst_size != 0 {
14810 len += 1;
14811 }
14812 if self.vnode_statistics.is_some() {
14813 len += 1;
14814 }
14815 if self.filter_type != 0 {
14816 len += 1;
14817 }
14818 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
14819 if self.object_id != 0 {
14820 #[allow(clippy::needless_borrow)]
14821 #[allow(clippy::needless_borrows_for_generic_args)]
14822 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
14823 }
14824 if self.sst_id != 0 {
14825 #[allow(clippy::needless_borrow)]
14826 #[allow(clippy::needless_borrows_for_generic_args)]
14827 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
14828 }
14829 if let Some(v) = self.key_range.as_ref() {
14830 struct_ser.serialize_field("keyRange", v)?;
14831 }
14832 if self.file_size != 0 {
14833 #[allow(clippy::needless_borrow)]
14834 #[allow(clippy::needless_borrows_for_generic_args)]
14835 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
14836 }
14837 if !self.table_ids.is_empty() {
14838 struct_ser.serialize_field("tableIds", &self.table_ids)?;
14839 }
14840 if self.meta_offset != 0 {
14841 #[allow(clippy::needless_borrow)]
14842 #[allow(clippy::needless_borrows_for_generic_args)]
14843 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
14844 }
14845 if self.stale_key_count != 0 {
14846 #[allow(clippy::needless_borrow)]
14847 #[allow(clippy::needless_borrows_for_generic_args)]
14848 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
14849 }
14850 if self.total_key_count != 0 {
14851 #[allow(clippy::needless_borrow)]
14852 #[allow(clippy::needless_borrows_for_generic_args)]
14853 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
14854 }
14855 if self.min_epoch != 0 {
14856 #[allow(clippy::needless_borrow)]
14857 #[allow(clippy::needless_borrows_for_generic_args)]
14858 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
14859 }
14860 if self.max_epoch != 0 {
14861 #[allow(clippy::needless_borrow)]
14862 #[allow(clippy::needless_borrows_for_generic_args)]
14863 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
14864 }
14865 if self.uncompressed_file_size != 0 {
14866 #[allow(clippy::needless_borrow)]
14867 #[allow(clippy::needless_borrows_for_generic_args)]
14868 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
14869 }
14870 if self.range_tombstone_count != 0 {
14871 #[allow(clippy::needless_borrow)]
14872 #[allow(clippy::needless_borrows_for_generic_args)]
14873 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
14874 }
14875 if self.bloom_filter_kind != 0 {
14876 let v = BloomFilterType::try_from(self.bloom_filter_kind)
14877 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
14878 struct_ser.serialize_field("bloomFilterKind", &v)?;
14879 }
14880 if self.sst_size != 0 {
14881 #[allow(clippy::needless_borrow)]
14882 #[allow(clippy::needless_borrows_for_generic_args)]
14883 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
14884 }
14885 if let Some(v) = self.vnode_statistics.as_ref() {
14886 struct_ser.serialize_field("vnodeStatistics", v)?;
14887 }
14888 if self.filter_type != 0 {
14889 let v = SstableFilterType::try_from(self.filter_type)
14890 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.filter_type)))?;
14891 struct_ser.serialize_field("filterType", &v)?;
14892 }
14893 struct_ser.end()
14894 }
14895}
14896impl<'de> serde::Deserialize<'de> for SstableInfo {
14897 #[allow(deprecated)]
14898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14899 where
14900 D: serde::Deserializer<'de>,
14901 {
14902 const FIELDS: &[&str] = &[
14903 "object_id",
14904 "objectId",
14905 "sst_id",
14906 "sstId",
14907 "key_range",
14908 "keyRange",
14909 "file_size",
14910 "fileSize",
14911 "table_ids",
14912 "tableIds",
14913 "meta_offset",
14914 "metaOffset",
14915 "stale_key_count",
14916 "staleKeyCount",
14917 "total_key_count",
14918 "totalKeyCount",
14919 "min_epoch",
14920 "minEpoch",
14921 "max_epoch",
14922 "maxEpoch",
14923 "uncompressed_file_size",
14924 "uncompressedFileSize",
14925 "range_tombstone_count",
14926 "rangeTombstoneCount",
14927 "bloom_filter_kind",
14928 "bloomFilterKind",
14929 "sst_size",
14930 "sstSize",
14931 "vnode_statistics",
14932 "vnodeStatistics",
14933 "filter_type",
14934 "filterType",
14935 ];
14936
14937 #[allow(clippy::enum_variant_names)]
14938 enum GeneratedField {
14939 ObjectId,
14940 SstId,
14941 KeyRange,
14942 FileSize,
14943 TableIds,
14944 MetaOffset,
14945 StaleKeyCount,
14946 TotalKeyCount,
14947 MinEpoch,
14948 MaxEpoch,
14949 UncompressedFileSize,
14950 RangeTombstoneCount,
14951 BloomFilterKind,
14952 SstSize,
14953 VnodeStatistics,
14954 FilterType,
14955 }
14956 impl<'de> serde::Deserialize<'de> for GeneratedField {
14957 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14958 where
14959 D: serde::Deserializer<'de>,
14960 {
14961 struct GeneratedVisitor;
14962
14963 impl serde::de::Visitor<'_> for GeneratedVisitor {
14964 type Value = GeneratedField;
14965
14966 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14967 write!(formatter, "expected one of: {:?}", &FIELDS)
14968 }
14969
14970 #[allow(unused_variables)]
14971 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14972 where
14973 E: serde::de::Error,
14974 {
14975 match value {
14976 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14977 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
14978 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
14979 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
14980 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
14981 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
14982 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
14983 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
14984 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
14985 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
14986 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
14987 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
14988 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
14989 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
14990 "vnodeStatistics" | "vnode_statistics" => Ok(GeneratedField::VnodeStatistics),
14991 "filterType" | "filter_type" => Ok(GeneratedField::FilterType),
14992 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14993 }
14994 }
14995 }
14996 deserializer.deserialize_identifier(GeneratedVisitor)
14997 }
14998 }
14999 struct GeneratedVisitor;
15000 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15001 type Value = SstableInfo;
15002
15003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15004 formatter.write_str("struct hummock.SstableInfo")
15005 }
15006
15007 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
15008 where
15009 V: serde::de::MapAccess<'de>,
15010 {
15011 let mut object_id__ = None;
15012 let mut sst_id__ = None;
15013 let mut key_range__ = None;
15014 let mut file_size__ = None;
15015 let mut table_ids__ = None;
15016 let mut meta_offset__ = None;
15017 let mut stale_key_count__ = None;
15018 let mut total_key_count__ = None;
15019 let mut min_epoch__ = None;
15020 let mut max_epoch__ = None;
15021 let mut uncompressed_file_size__ = None;
15022 let mut range_tombstone_count__ = None;
15023 let mut bloom_filter_kind__ = None;
15024 let mut sst_size__ = None;
15025 let mut vnode_statistics__ = None;
15026 let mut filter_type__ = None;
15027 while let Some(k) = map_.next_key()? {
15028 match k {
15029 GeneratedField::ObjectId => {
15030 if object_id__.is_some() {
15031 return Err(serde::de::Error::duplicate_field("objectId"));
15032 }
15033 object_id__ =
15034 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15035 ;
15036 }
15037 GeneratedField::SstId => {
15038 if sst_id__.is_some() {
15039 return Err(serde::de::Error::duplicate_field("sstId"));
15040 }
15041 sst_id__ =
15042 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15043 ;
15044 }
15045 GeneratedField::KeyRange => {
15046 if key_range__.is_some() {
15047 return Err(serde::de::Error::duplicate_field("keyRange"));
15048 }
15049 key_range__ = map_.next_value()?;
15050 }
15051 GeneratedField::FileSize => {
15052 if file_size__.is_some() {
15053 return Err(serde::de::Error::duplicate_field("fileSize"));
15054 }
15055 file_size__ =
15056 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15057 ;
15058 }
15059 GeneratedField::TableIds => {
15060 if table_ids__.is_some() {
15061 return Err(serde::de::Error::duplicate_field("tableIds"));
15062 }
15063 table_ids__ =
15064 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15065 .into_iter().map(|x| x.0).collect())
15066 ;
15067 }
15068 GeneratedField::MetaOffset => {
15069 if meta_offset__.is_some() {
15070 return Err(serde::de::Error::duplicate_field("metaOffset"));
15071 }
15072 meta_offset__ =
15073 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15074 ;
15075 }
15076 GeneratedField::StaleKeyCount => {
15077 if stale_key_count__.is_some() {
15078 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
15079 }
15080 stale_key_count__ =
15081 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15082 ;
15083 }
15084 GeneratedField::TotalKeyCount => {
15085 if total_key_count__.is_some() {
15086 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
15087 }
15088 total_key_count__ =
15089 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15090 ;
15091 }
15092 GeneratedField::MinEpoch => {
15093 if min_epoch__.is_some() {
15094 return Err(serde::de::Error::duplicate_field("minEpoch"));
15095 }
15096 min_epoch__ =
15097 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15098 ;
15099 }
15100 GeneratedField::MaxEpoch => {
15101 if max_epoch__.is_some() {
15102 return Err(serde::de::Error::duplicate_field("maxEpoch"));
15103 }
15104 max_epoch__ =
15105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15106 ;
15107 }
15108 GeneratedField::UncompressedFileSize => {
15109 if uncompressed_file_size__.is_some() {
15110 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
15111 }
15112 uncompressed_file_size__ =
15113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15114 ;
15115 }
15116 GeneratedField::RangeTombstoneCount => {
15117 if range_tombstone_count__.is_some() {
15118 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
15119 }
15120 range_tombstone_count__ =
15121 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15122 ;
15123 }
15124 GeneratedField::BloomFilterKind => {
15125 if bloom_filter_kind__.is_some() {
15126 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
15127 }
15128 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
15129 }
15130 GeneratedField::SstSize => {
15131 if sst_size__.is_some() {
15132 return Err(serde::de::Error::duplicate_field("sstSize"));
15133 }
15134 sst_size__ =
15135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15136 ;
15137 }
15138 GeneratedField::VnodeStatistics => {
15139 if vnode_statistics__.is_some() {
15140 return Err(serde::de::Error::duplicate_field("vnodeStatistics"));
15141 }
15142 vnode_statistics__ = map_.next_value()?;
15143 }
15144 GeneratedField::FilterType => {
15145 if filter_type__.is_some() {
15146 return Err(serde::de::Error::duplicate_field("filterType"));
15147 }
15148 filter_type__ = Some(map_.next_value::<SstableFilterType>()? as i32);
15149 }
15150 }
15151 }
15152 Ok(SstableInfo {
15153 object_id: object_id__.unwrap_or_default(),
15154 sst_id: sst_id__.unwrap_or_default(),
15155 key_range: key_range__,
15156 file_size: file_size__.unwrap_or_default(),
15157 table_ids: table_ids__.unwrap_or_default(),
15158 meta_offset: meta_offset__.unwrap_or_default(),
15159 stale_key_count: stale_key_count__.unwrap_or_default(),
15160 total_key_count: total_key_count__.unwrap_or_default(),
15161 min_epoch: min_epoch__.unwrap_or_default(),
15162 max_epoch: max_epoch__.unwrap_or_default(),
15163 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
15164 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
15165 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
15166 sst_size: sst_size__.unwrap_or_default(),
15167 vnode_statistics: vnode_statistics__,
15168 filter_type: filter_type__.unwrap_or_default(),
15169 })
15170 }
15171 }
15172 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
15173 }
15174}
15175impl serde::Serialize for StateTableInfo {
15176 #[allow(deprecated)]
15177 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15178 where
15179 S: serde::Serializer,
15180 {
15181 use serde::ser::SerializeStruct;
15182 let mut len = 0;
15183 if self.committed_epoch != 0 {
15184 len += 1;
15185 }
15186 if self.compaction_group_id != 0 {
15187 len += 1;
15188 }
15189 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
15190 if self.committed_epoch != 0 {
15191 #[allow(clippy::needless_borrow)]
15192 #[allow(clippy::needless_borrows_for_generic_args)]
15193 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
15194 }
15195 if self.compaction_group_id != 0 {
15196 #[allow(clippy::needless_borrow)]
15197 #[allow(clippy::needless_borrows_for_generic_args)]
15198 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
15199 }
15200 struct_ser.end()
15201 }
15202}
15203impl<'de> serde::Deserialize<'de> for StateTableInfo {
15204 #[allow(deprecated)]
15205 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15206 where
15207 D: serde::Deserializer<'de>,
15208 {
15209 const FIELDS: &[&str] = &[
15210 "committed_epoch",
15211 "committedEpoch",
15212 "compaction_group_id",
15213 "compactionGroupId",
15214 ];
15215
15216 #[allow(clippy::enum_variant_names)]
15217 enum GeneratedField {
15218 CommittedEpoch,
15219 CompactionGroupId,
15220 }
15221 impl<'de> serde::Deserialize<'de> for GeneratedField {
15222 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15223 where
15224 D: serde::Deserializer<'de>,
15225 {
15226 struct GeneratedVisitor;
15227
15228 impl serde::de::Visitor<'_> for GeneratedVisitor {
15229 type Value = GeneratedField;
15230
15231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15232 write!(formatter, "expected one of: {:?}", &FIELDS)
15233 }
15234
15235 #[allow(unused_variables)]
15236 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15237 where
15238 E: serde::de::Error,
15239 {
15240 match value {
15241 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
15242 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
15243 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15244 }
15245 }
15246 }
15247 deserializer.deserialize_identifier(GeneratedVisitor)
15248 }
15249 }
15250 struct GeneratedVisitor;
15251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15252 type Value = StateTableInfo;
15253
15254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15255 formatter.write_str("struct hummock.StateTableInfo")
15256 }
15257
15258 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
15259 where
15260 V: serde::de::MapAccess<'de>,
15261 {
15262 let mut committed_epoch__ = None;
15263 let mut compaction_group_id__ = None;
15264 while let Some(k) = map_.next_key()? {
15265 match k {
15266 GeneratedField::CommittedEpoch => {
15267 if committed_epoch__.is_some() {
15268 return Err(serde::de::Error::duplicate_field("committedEpoch"));
15269 }
15270 committed_epoch__ =
15271 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15272 ;
15273 }
15274 GeneratedField::CompactionGroupId => {
15275 if compaction_group_id__.is_some() {
15276 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
15277 }
15278 compaction_group_id__ =
15279 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15280 ;
15281 }
15282 }
15283 }
15284 Ok(StateTableInfo {
15285 committed_epoch: committed_epoch__.unwrap_or_default(),
15286 compaction_group_id: compaction_group_id__.unwrap_or_default(),
15287 })
15288 }
15289 }
15290 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
15291 }
15292}
15293impl serde::Serialize for StateTableInfoDelta {
15294 #[allow(deprecated)]
15295 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15296 where
15297 S: serde::Serializer,
15298 {
15299 use serde::ser::SerializeStruct;
15300 let mut len = 0;
15301 if self.committed_epoch != 0 {
15302 len += 1;
15303 }
15304 if self.compaction_group_id != 0 {
15305 len += 1;
15306 }
15307 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
15308 if self.committed_epoch != 0 {
15309 #[allow(clippy::needless_borrow)]
15310 #[allow(clippy::needless_borrows_for_generic_args)]
15311 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
15312 }
15313 if self.compaction_group_id != 0 {
15314 #[allow(clippy::needless_borrow)]
15315 #[allow(clippy::needless_borrows_for_generic_args)]
15316 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
15317 }
15318 struct_ser.end()
15319 }
15320}
15321impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
15322 #[allow(deprecated)]
15323 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15324 where
15325 D: serde::Deserializer<'de>,
15326 {
15327 const FIELDS: &[&str] = &[
15328 "committed_epoch",
15329 "committedEpoch",
15330 "compaction_group_id",
15331 "compactionGroupId",
15332 ];
15333
15334 #[allow(clippy::enum_variant_names)]
15335 enum GeneratedField {
15336 CommittedEpoch,
15337 CompactionGroupId,
15338 }
15339 impl<'de> serde::Deserialize<'de> for GeneratedField {
15340 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15341 where
15342 D: serde::Deserializer<'de>,
15343 {
15344 struct GeneratedVisitor;
15345
15346 impl serde::de::Visitor<'_> for GeneratedVisitor {
15347 type Value = GeneratedField;
15348
15349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15350 write!(formatter, "expected one of: {:?}", &FIELDS)
15351 }
15352
15353 #[allow(unused_variables)]
15354 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15355 where
15356 E: serde::de::Error,
15357 {
15358 match value {
15359 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
15360 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
15361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15362 }
15363 }
15364 }
15365 deserializer.deserialize_identifier(GeneratedVisitor)
15366 }
15367 }
15368 struct GeneratedVisitor;
15369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15370 type Value = StateTableInfoDelta;
15371
15372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15373 formatter.write_str("struct hummock.StateTableInfoDelta")
15374 }
15375
15376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
15377 where
15378 V: serde::de::MapAccess<'de>,
15379 {
15380 let mut committed_epoch__ = None;
15381 let mut compaction_group_id__ = None;
15382 while let Some(k) = map_.next_key()? {
15383 match k {
15384 GeneratedField::CommittedEpoch => {
15385 if committed_epoch__.is_some() {
15386 return Err(serde::de::Error::duplicate_field("committedEpoch"));
15387 }
15388 committed_epoch__ =
15389 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15390 ;
15391 }
15392 GeneratedField::CompactionGroupId => {
15393 if compaction_group_id__.is_some() {
15394 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
15395 }
15396 compaction_group_id__ =
15397 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15398 ;
15399 }
15400 }
15401 }
15402 Ok(StateTableInfoDelta {
15403 committed_epoch: committed_epoch__.unwrap_or_default(),
15404 compaction_group_id: compaction_group_id__.unwrap_or_default(),
15405 })
15406 }
15407 }
15408 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
15409 }
15410}
15411impl serde::Serialize for SubscribeCompactionEventRequest {
15412 #[allow(deprecated)]
15413 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15414 where
15415 S: serde::Serializer,
15416 {
15417 use serde::ser::SerializeStruct;
15418 let mut len = 0;
15419 if self.create_at != 0 {
15420 len += 1;
15421 }
15422 if self.event.is_some() {
15423 len += 1;
15424 }
15425 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
15426 if self.create_at != 0 {
15427 #[allow(clippy::needless_borrow)]
15428 #[allow(clippy::needless_borrows_for_generic_args)]
15429 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
15430 }
15431 if let Some(v) = self.event.as_ref() {
15432 match v {
15433 subscribe_compaction_event_request::Event::Register(v) => {
15434 struct_ser.serialize_field("register", v)?;
15435 }
15436 subscribe_compaction_event_request::Event::PullTask(v) => {
15437 struct_ser.serialize_field("pullTask", v)?;
15438 }
15439 subscribe_compaction_event_request::Event::ReportTask(v) => {
15440 struct_ser.serialize_field("reportTask", v)?;
15441 }
15442 subscribe_compaction_event_request::Event::HeartBeat(v) => {
15443 struct_ser.serialize_field("heartBeat", v)?;
15444 }
15445 }
15446 }
15447 struct_ser.end()
15448 }
15449}
15450impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
15451 #[allow(deprecated)]
15452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15453 where
15454 D: serde::Deserializer<'de>,
15455 {
15456 const FIELDS: &[&str] = &[
15457 "create_at",
15458 "createAt",
15459 "register",
15460 "pull_task",
15461 "pullTask",
15462 "report_task",
15463 "reportTask",
15464 "heart_beat",
15465 "heartBeat",
15466 ];
15467
15468 #[allow(clippy::enum_variant_names)]
15469 enum GeneratedField {
15470 CreateAt,
15471 Register,
15472 PullTask,
15473 ReportTask,
15474 HeartBeat,
15475 }
15476 impl<'de> serde::Deserialize<'de> for GeneratedField {
15477 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15478 where
15479 D: serde::Deserializer<'de>,
15480 {
15481 struct GeneratedVisitor;
15482
15483 impl serde::de::Visitor<'_> for GeneratedVisitor {
15484 type Value = GeneratedField;
15485
15486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15487 write!(formatter, "expected one of: {:?}", &FIELDS)
15488 }
15489
15490 #[allow(unused_variables)]
15491 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15492 where
15493 E: serde::de::Error,
15494 {
15495 match value {
15496 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
15497 "register" => Ok(GeneratedField::Register),
15498 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
15499 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
15500 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
15501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15502 }
15503 }
15504 }
15505 deserializer.deserialize_identifier(GeneratedVisitor)
15506 }
15507 }
15508 struct GeneratedVisitor;
15509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15510 type Value = SubscribeCompactionEventRequest;
15511
15512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15513 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
15514 }
15515
15516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
15517 where
15518 V: serde::de::MapAccess<'de>,
15519 {
15520 let mut create_at__ = None;
15521 let mut event__ = None;
15522 while let Some(k) = map_.next_key()? {
15523 match k {
15524 GeneratedField::CreateAt => {
15525 if create_at__.is_some() {
15526 return Err(serde::de::Error::duplicate_field("createAt"));
15527 }
15528 create_at__ =
15529 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15530 ;
15531 }
15532 GeneratedField::Register => {
15533 if event__.is_some() {
15534 return Err(serde::de::Error::duplicate_field("register"));
15535 }
15536 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
15537;
15538 }
15539 GeneratedField::PullTask => {
15540 if event__.is_some() {
15541 return Err(serde::de::Error::duplicate_field("pullTask"));
15542 }
15543 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
15544;
15545 }
15546 GeneratedField::ReportTask => {
15547 if event__.is_some() {
15548 return Err(serde::de::Error::duplicate_field("reportTask"));
15549 }
15550 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
15551;
15552 }
15553 GeneratedField::HeartBeat => {
15554 if event__.is_some() {
15555 return Err(serde::de::Error::duplicate_field("heartBeat"));
15556 }
15557 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
15558;
15559 }
15560 }
15561 }
15562 Ok(SubscribeCompactionEventRequest {
15563 create_at: create_at__.unwrap_or_default(),
15564 event: event__,
15565 })
15566 }
15567 }
15568 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
15569 }
15570}
15571impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
15572 #[allow(deprecated)]
15573 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15574 where
15575 S: serde::Serializer,
15576 {
15577 use serde::ser::SerializeStruct;
15578 let mut len = 0;
15579 if !self.progress.is_empty() {
15580 len += 1;
15581 }
15582 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
15583 if !self.progress.is_empty() {
15584 struct_ser.serialize_field("progress", &self.progress)?;
15585 }
15586 struct_ser.end()
15587 }
15588}
15589impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
15590 #[allow(deprecated)]
15591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15592 where
15593 D: serde::Deserializer<'de>,
15594 {
15595 const FIELDS: &[&str] = &[
15596 "progress",
15597 ];
15598
15599 #[allow(clippy::enum_variant_names)]
15600 enum GeneratedField {
15601 Progress,
15602 }
15603 impl<'de> serde::Deserialize<'de> for GeneratedField {
15604 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15605 where
15606 D: serde::Deserializer<'de>,
15607 {
15608 struct GeneratedVisitor;
15609
15610 impl serde::de::Visitor<'_> for GeneratedVisitor {
15611 type Value = GeneratedField;
15612
15613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15614 write!(formatter, "expected one of: {:?}", &FIELDS)
15615 }
15616
15617 #[allow(unused_variables)]
15618 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15619 where
15620 E: serde::de::Error,
15621 {
15622 match value {
15623 "progress" => Ok(GeneratedField::Progress),
15624 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15625 }
15626 }
15627 }
15628 deserializer.deserialize_identifier(GeneratedVisitor)
15629 }
15630 }
15631 struct GeneratedVisitor;
15632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15633 type Value = subscribe_compaction_event_request::HeartBeat;
15634
15635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15636 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
15637 }
15638
15639 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
15640 where
15641 V: serde::de::MapAccess<'de>,
15642 {
15643 let mut progress__ = None;
15644 while let Some(k) = map_.next_key()? {
15645 match k {
15646 GeneratedField::Progress => {
15647 if progress__.is_some() {
15648 return Err(serde::de::Error::duplicate_field("progress"));
15649 }
15650 progress__ = Some(map_.next_value()?);
15651 }
15652 }
15653 }
15654 Ok(subscribe_compaction_event_request::HeartBeat {
15655 progress: progress__.unwrap_or_default(),
15656 })
15657 }
15658 }
15659 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
15660 }
15661}
15662impl serde::Serialize for subscribe_compaction_event_request::PullTask {
15663 #[allow(deprecated)]
15664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15665 where
15666 S: serde::Serializer,
15667 {
15668 use serde::ser::SerializeStruct;
15669 let mut len = 0;
15670 if self.pull_task_count != 0 {
15671 len += 1;
15672 }
15673 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
15674 if self.pull_task_count != 0 {
15675 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
15676 }
15677 struct_ser.end()
15678 }
15679}
15680impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
15681 #[allow(deprecated)]
15682 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15683 where
15684 D: serde::Deserializer<'de>,
15685 {
15686 const FIELDS: &[&str] = &[
15687 "pull_task_count",
15688 "pullTaskCount",
15689 ];
15690
15691 #[allow(clippy::enum_variant_names)]
15692 enum GeneratedField {
15693 PullTaskCount,
15694 }
15695 impl<'de> serde::Deserialize<'de> for GeneratedField {
15696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15697 where
15698 D: serde::Deserializer<'de>,
15699 {
15700 struct GeneratedVisitor;
15701
15702 impl serde::de::Visitor<'_> for GeneratedVisitor {
15703 type Value = GeneratedField;
15704
15705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15706 write!(formatter, "expected one of: {:?}", &FIELDS)
15707 }
15708
15709 #[allow(unused_variables)]
15710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15711 where
15712 E: serde::de::Error,
15713 {
15714 match value {
15715 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
15716 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15717 }
15718 }
15719 }
15720 deserializer.deserialize_identifier(GeneratedVisitor)
15721 }
15722 }
15723 struct GeneratedVisitor;
15724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15725 type Value = subscribe_compaction_event_request::PullTask;
15726
15727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15728 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
15729 }
15730
15731 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
15732 where
15733 V: serde::de::MapAccess<'de>,
15734 {
15735 let mut pull_task_count__ = None;
15736 while let Some(k) = map_.next_key()? {
15737 match k {
15738 GeneratedField::PullTaskCount => {
15739 if pull_task_count__.is_some() {
15740 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
15741 }
15742 pull_task_count__ =
15743 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15744 ;
15745 }
15746 }
15747 }
15748 Ok(subscribe_compaction_event_request::PullTask {
15749 pull_task_count: pull_task_count__.unwrap_or_default(),
15750 })
15751 }
15752 }
15753 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
15754 }
15755}
15756impl serde::Serialize for subscribe_compaction_event_request::Register {
15757 #[allow(deprecated)]
15758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15759 where
15760 S: serde::Serializer,
15761 {
15762 use serde::ser::SerializeStruct;
15763 let mut len = 0;
15764 if self.context_id != 0 {
15765 len += 1;
15766 }
15767 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
15768 if self.context_id != 0 {
15769 struct_ser.serialize_field("contextId", &self.context_id)?;
15770 }
15771 struct_ser.end()
15772 }
15773}
15774impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
15775 #[allow(deprecated)]
15776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15777 where
15778 D: serde::Deserializer<'de>,
15779 {
15780 const FIELDS: &[&str] = &[
15781 "context_id",
15782 "contextId",
15783 ];
15784
15785 #[allow(clippy::enum_variant_names)]
15786 enum GeneratedField {
15787 ContextId,
15788 }
15789 impl<'de> serde::Deserialize<'de> for GeneratedField {
15790 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15791 where
15792 D: serde::Deserializer<'de>,
15793 {
15794 struct GeneratedVisitor;
15795
15796 impl serde::de::Visitor<'_> for GeneratedVisitor {
15797 type Value = GeneratedField;
15798
15799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15800 write!(formatter, "expected one of: {:?}", &FIELDS)
15801 }
15802
15803 #[allow(unused_variables)]
15804 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15805 where
15806 E: serde::de::Error,
15807 {
15808 match value {
15809 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15811 }
15812 }
15813 }
15814 deserializer.deserialize_identifier(GeneratedVisitor)
15815 }
15816 }
15817 struct GeneratedVisitor;
15818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15819 type Value = subscribe_compaction_event_request::Register;
15820
15821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15822 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
15823 }
15824
15825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
15826 where
15827 V: serde::de::MapAccess<'de>,
15828 {
15829 let mut context_id__ = None;
15830 while let Some(k) = map_.next_key()? {
15831 match k {
15832 GeneratedField::ContextId => {
15833 if context_id__.is_some() {
15834 return Err(serde::de::Error::duplicate_field("contextId"));
15835 }
15836 context_id__ =
15837 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15838 ;
15839 }
15840 }
15841 }
15842 Ok(subscribe_compaction_event_request::Register {
15843 context_id: context_id__.unwrap_or_default(),
15844 })
15845 }
15846 }
15847 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
15848 }
15849}
15850impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
15851 #[allow(deprecated)]
15852 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15853 where
15854 S: serde::Serializer,
15855 {
15856 use serde::ser::SerializeStruct;
15857 let mut len = 0;
15858 if !self.table_stats_change.is_empty() {
15859 len += 1;
15860 }
15861 if self.task_id != 0 {
15862 len += 1;
15863 }
15864 if self.task_status != 0 {
15865 len += 1;
15866 }
15867 if !self.sorted_output_ssts.is_empty() {
15868 len += 1;
15869 }
15870 if !self.object_timestamps.is_empty() {
15871 len += 1;
15872 }
15873 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
15874 if !self.table_stats_change.is_empty() {
15875 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
15876 }
15877 if self.task_id != 0 {
15878 #[allow(clippy::needless_borrow)]
15879 #[allow(clippy::needless_borrows_for_generic_args)]
15880 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
15881 }
15882 if self.task_status != 0 {
15883 let v = compact_task::TaskStatus::try_from(self.task_status)
15884 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
15885 struct_ser.serialize_field("taskStatus", &v)?;
15886 }
15887 if !self.sorted_output_ssts.is_empty() {
15888 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
15889 }
15890 if !self.object_timestamps.is_empty() {
15891 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
15892 .map(|(k, v)| (k, v.to_string())).collect();
15893 struct_ser.serialize_field("objectTimestamps", &v)?;
15894 }
15895 struct_ser.end()
15896 }
15897}
15898impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
15899 #[allow(deprecated)]
15900 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15901 where
15902 D: serde::Deserializer<'de>,
15903 {
15904 const FIELDS: &[&str] = &[
15905 "table_stats_change",
15906 "tableStatsChange",
15907 "task_id",
15908 "taskId",
15909 "task_status",
15910 "taskStatus",
15911 "sorted_output_ssts",
15912 "sortedOutputSsts",
15913 "object_timestamps",
15914 "objectTimestamps",
15915 ];
15916
15917 #[allow(clippy::enum_variant_names)]
15918 enum GeneratedField {
15919 TableStatsChange,
15920 TaskId,
15921 TaskStatus,
15922 SortedOutputSsts,
15923 ObjectTimestamps,
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 serde::de::Visitor<'_> 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 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
15946 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
15947 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
15948 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
15949 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
15950 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15951 }
15952 }
15953 }
15954 deserializer.deserialize_identifier(GeneratedVisitor)
15955 }
15956 }
15957 struct GeneratedVisitor;
15958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15959 type Value = subscribe_compaction_event_request::ReportTask;
15960
15961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15962 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
15963 }
15964
15965 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
15966 where
15967 V: serde::de::MapAccess<'de>,
15968 {
15969 let mut table_stats_change__ = None;
15970 let mut task_id__ = None;
15971 let mut task_status__ = None;
15972 let mut sorted_output_ssts__ = None;
15973 let mut object_timestamps__ = None;
15974 while let Some(k) = map_.next_key()? {
15975 match k {
15976 GeneratedField::TableStatsChange => {
15977 if table_stats_change__.is_some() {
15978 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
15979 }
15980 table_stats_change__ = Some(
15981 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15982 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15983 );
15984 }
15985 GeneratedField::TaskId => {
15986 if task_id__.is_some() {
15987 return Err(serde::de::Error::duplicate_field("taskId"));
15988 }
15989 task_id__ =
15990 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15991 ;
15992 }
15993 GeneratedField::TaskStatus => {
15994 if task_status__.is_some() {
15995 return Err(serde::de::Error::duplicate_field("taskStatus"));
15996 }
15997 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
15998 }
15999 GeneratedField::SortedOutputSsts => {
16000 if sorted_output_ssts__.is_some() {
16001 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
16002 }
16003 sorted_output_ssts__ = Some(map_.next_value()?);
16004 }
16005 GeneratedField::ObjectTimestamps => {
16006 if object_timestamps__.is_some() {
16007 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
16008 }
16009 object_timestamps__ = Some(
16010 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
16011 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
16012 );
16013 }
16014 }
16015 }
16016 Ok(subscribe_compaction_event_request::ReportTask {
16017 table_stats_change: table_stats_change__.unwrap_or_default(),
16018 task_id: task_id__.unwrap_or_default(),
16019 task_status: task_status__.unwrap_or_default(),
16020 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
16021 object_timestamps: object_timestamps__.unwrap_or_default(),
16022 })
16023 }
16024 }
16025 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
16026 }
16027}
16028impl serde::Serialize for SubscribeCompactionEventResponse {
16029 #[allow(deprecated)]
16030 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16031 where
16032 S: serde::Serializer,
16033 {
16034 use serde::ser::SerializeStruct;
16035 let mut len = 0;
16036 if self.create_at != 0 {
16037 len += 1;
16038 }
16039 if self.event.is_some() {
16040 len += 1;
16041 }
16042 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
16043 if self.create_at != 0 {
16044 #[allow(clippy::needless_borrow)]
16045 #[allow(clippy::needless_borrows_for_generic_args)]
16046 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
16047 }
16048 if let Some(v) = self.event.as_ref() {
16049 match v {
16050 subscribe_compaction_event_response::Event::CompactTask(v) => {
16051 struct_ser.serialize_field("compactTask", v)?;
16052 }
16053 subscribe_compaction_event_response::Event::VacuumTask(v) => {
16054 struct_ser.serialize_field("vacuumTask", v)?;
16055 }
16056 subscribe_compaction_event_response::Event::FullScanTask(v) => {
16057 struct_ser.serialize_field("fullScanTask", v)?;
16058 }
16059 subscribe_compaction_event_response::Event::ValidationTask(v) => {
16060 struct_ser.serialize_field("validationTask", v)?;
16061 }
16062 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
16063 struct_ser.serialize_field("cancelCompactTask", v)?;
16064 }
16065 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
16066 struct_ser.serialize_field("pullTaskAck", v)?;
16067 }
16068 }
16069 }
16070 struct_ser.end()
16071 }
16072}
16073impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
16074 #[allow(deprecated)]
16075 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16076 where
16077 D: serde::Deserializer<'de>,
16078 {
16079 const FIELDS: &[&str] = &[
16080 "create_at",
16081 "createAt",
16082 "compact_task",
16083 "compactTask",
16084 "vacuum_task",
16085 "vacuumTask",
16086 "full_scan_task",
16087 "fullScanTask",
16088 "validation_task",
16089 "validationTask",
16090 "cancel_compact_task",
16091 "cancelCompactTask",
16092 "pull_task_ack",
16093 "pullTaskAck",
16094 ];
16095
16096 #[allow(clippy::enum_variant_names)]
16097 enum GeneratedField {
16098 CreateAt,
16099 CompactTask,
16100 VacuumTask,
16101 FullScanTask,
16102 ValidationTask,
16103 CancelCompactTask,
16104 PullTaskAck,
16105 }
16106 impl<'de> serde::Deserialize<'de> for GeneratedField {
16107 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16108 where
16109 D: serde::Deserializer<'de>,
16110 {
16111 struct GeneratedVisitor;
16112
16113 impl serde::de::Visitor<'_> for GeneratedVisitor {
16114 type Value = GeneratedField;
16115
16116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16117 write!(formatter, "expected one of: {:?}", &FIELDS)
16118 }
16119
16120 #[allow(unused_variables)]
16121 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16122 where
16123 E: serde::de::Error,
16124 {
16125 match value {
16126 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
16127 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
16128 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
16129 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
16130 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
16131 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
16132 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
16133 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16134 }
16135 }
16136 }
16137 deserializer.deserialize_identifier(GeneratedVisitor)
16138 }
16139 }
16140 struct GeneratedVisitor;
16141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16142 type Value = SubscribeCompactionEventResponse;
16143
16144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16145 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
16146 }
16147
16148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
16149 where
16150 V: serde::de::MapAccess<'de>,
16151 {
16152 let mut create_at__ = None;
16153 let mut event__ = None;
16154 while let Some(k) = map_.next_key()? {
16155 match k {
16156 GeneratedField::CreateAt => {
16157 if create_at__.is_some() {
16158 return Err(serde::de::Error::duplicate_field("createAt"));
16159 }
16160 create_at__ =
16161 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16162 ;
16163 }
16164 GeneratedField::CompactTask => {
16165 if event__.is_some() {
16166 return Err(serde::de::Error::duplicate_field("compactTask"));
16167 }
16168 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
16169;
16170 }
16171 GeneratedField::VacuumTask => {
16172 if event__.is_some() {
16173 return Err(serde::de::Error::duplicate_field("vacuumTask"));
16174 }
16175 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
16176;
16177 }
16178 GeneratedField::FullScanTask => {
16179 if event__.is_some() {
16180 return Err(serde::de::Error::duplicate_field("fullScanTask"));
16181 }
16182 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
16183;
16184 }
16185 GeneratedField::ValidationTask => {
16186 if event__.is_some() {
16187 return Err(serde::de::Error::duplicate_field("validationTask"));
16188 }
16189 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
16190;
16191 }
16192 GeneratedField::CancelCompactTask => {
16193 if event__.is_some() {
16194 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
16195 }
16196 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
16197;
16198 }
16199 GeneratedField::PullTaskAck => {
16200 if event__.is_some() {
16201 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
16202 }
16203 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
16204;
16205 }
16206 }
16207 }
16208 Ok(SubscribeCompactionEventResponse {
16209 create_at: create_at__.unwrap_or_default(),
16210 event: event__,
16211 })
16212 }
16213 }
16214 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
16215 }
16216}
16217impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
16218 #[allow(deprecated)]
16219 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16220 where
16221 S: serde::Serializer,
16222 {
16223 use serde::ser::SerializeStruct;
16224 let len = 0;
16225 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
16226 struct_ser.end()
16227 }
16228}
16229impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
16230 #[allow(deprecated)]
16231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16232 where
16233 D: serde::Deserializer<'de>,
16234 {
16235 const FIELDS: &[&str] = &[
16236 ];
16237
16238 #[allow(clippy::enum_variant_names)]
16239 enum GeneratedField {
16240 }
16241 impl<'de> serde::Deserialize<'de> for GeneratedField {
16242 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16243 where
16244 D: serde::Deserializer<'de>,
16245 {
16246 struct GeneratedVisitor;
16247
16248 impl serde::de::Visitor<'_> for GeneratedVisitor {
16249 type Value = GeneratedField;
16250
16251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16252 write!(formatter, "expected one of: {:?}", &FIELDS)
16253 }
16254
16255 #[allow(unused_variables)]
16256 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16257 where
16258 E: serde::de::Error,
16259 {
16260 Err(serde::de::Error::unknown_field(value, FIELDS))
16261 }
16262 }
16263 deserializer.deserialize_identifier(GeneratedVisitor)
16264 }
16265 }
16266 struct GeneratedVisitor;
16267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16268 type Value = subscribe_compaction_event_response::PullTaskAck;
16269
16270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16271 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
16272 }
16273
16274 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
16275 where
16276 V: serde::de::MapAccess<'de>,
16277 {
16278 while map_.next_key::<GeneratedField>()?.is_some() {
16279 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16280 }
16281 Ok(subscribe_compaction_event_response::PullTaskAck {
16282 })
16283 }
16284 }
16285 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
16286 }
16287}
16288impl serde::Serialize for TableChangeLog {
16289 #[allow(deprecated)]
16290 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16291 where
16292 S: serde::Serializer,
16293 {
16294 use serde::ser::SerializeStruct;
16295 let mut len = 0;
16296 if !self.change_logs.is_empty() {
16297 len += 1;
16298 }
16299 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
16300 if !self.change_logs.is_empty() {
16301 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
16302 }
16303 struct_ser.end()
16304 }
16305}
16306impl<'de> serde::Deserialize<'de> for TableChangeLog {
16307 #[allow(deprecated)]
16308 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16309 where
16310 D: serde::Deserializer<'de>,
16311 {
16312 const FIELDS: &[&str] = &[
16313 "change_logs",
16314 "changeLogs",
16315 ];
16316
16317 #[allow(clippy::enum_variant_names)]
16318 enum GeneratedField {
16319 ChangeLogs,
16320 }
16321 impl<'de> serde::Deserialize<'de> for GeneratedField {
16322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16323 where
16324 D: serde::Deserializer<'de>,
16325 {
16326 struct GeneratedVisitor;
16327
16328 impl serde::de::Visitor<'_> for GeneratedVisitor {
16329 type Value = GeneratedField;
16330
16331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16332 write!(formatter, "expected one of: {:?}", &FIELDS)
16333 }
16334
16335 #[allow(unused_variables)]
16336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16337 where
16338 E: serde::de::Error,
16339 {
16340 match value {
16341 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
16342 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16343 }
16344 }
16345 }
16346 deserializer.deserialize_identifier(GeneratedVisitor)
16347 }
16348 }
16349 struct GeneratedVisitor;
16350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16351 type Value = TableChangeLog;
16352
16353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16354 formatter.write_str("struct hummock.TableChangeLog")
16355 }
16356
16357 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
16358 where
16359 V: serde::de::MapAccess<'de>,
16360 {
16361 let mut change_logs__ = None;
16362 while let Some(k) = map_.next_key()? {
16363 match k {
16364 GeneratedField::ChangeLogs => {
16365 if change_logs__.is_some() {
16366 return Err(serde::de::Error::duplicate_field("changeLogs"));
16367 }
16368 change_logs__ = Some(map_.next_value()?);
16369 }
16370 }
16371 }
16372 Ok(TableChangeLog {
16373 change_logs: change_logs__.unwrap_or_default(),
16374 })
16375 }
16376 }
16377 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
16378 }
16379}
16380impl serde::Serialize for TableOption {
16381 #[allow(deprecated)]
16382 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16383 where
16384 S: serde::Serializer,
16385 {
16386 use serde::ser::SerializeStruct;
16387 let mut len = 0;
16388 if self.retention_seconds.is_some() {
16389 len += 1;
16390 }
16391 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
16392 if let Some(v) = self.retention_seconds.as_ref() {
16393 struct_ser.serialize_field("retentionSeconds", v)?;
16394 }
16395 struct_ser.end()
16396 }
16397}
16398impl<'de> serde::Deserialize<'de> for TableOption {
16399 #[allow(deprecated)]
16400 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16401 where
16402 D: serde::Deserializer<'de>,
16403 {
16404 const FIELDS: &[&str] = &[
16405 "retention_seconds",
16406 "retentionSeconds",
16407 ];
16408
16409 #[allow(clippy::enum_variant_names)]
16410 enum GeneratedField {
16411 RetentionSeconds,
16412 }
16413 impl<'de> serde::Deserialize<'de> for GeneratedField {
16414 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16415 where
16416 D: serde::Deserializer<'de>,
16417 {
16418 struct GeneratedVisitor;
16419
16420 impl serde::de::Visitor<'_> for GeneratedVisitor {
16421 type Value = GeneratedField;
16422
16423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16424 write!(formatter, "expected one of: {:?}", &FIELDS)
16425 }
16426
16427 #[allow(unused_variables)]
16428 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16429 where
16430 E: serde::de::Error,
16431 {
16432 match value {
16433 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
16434 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16435 }
16436 }
16437 }
16438 deserializer.deserialize_identifier(GeneratedVisitor)
16439 }
16440 }
16441 struct GeneratedVisitor;
16442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16443 type Value = TableOption;
16444
16445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16446 formatter.write_str("struct hummock.TableOption")
16447 }
16448
16449 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
16450 where
16451 V: serde::de::MapAccess<'de>,
16452 {
16453 let mut retention_seconds__ = None;
16454 while let Some(k) = map_.next_key()? {
16455 match k {
16456 GeneratedField::RetentionSeconds => {
16457 if retention_seconds__.is_some() {
16458 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
16459 }
16460 retention_seconds__ =
16461 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16462 ;
16463 }
16464 }
16465 }
16466 Ok(TableOption {
16467 retention_seconds: retention_seconds__,
16468 })
16469 }
16470 }
16471 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
16472 }
16473}
16474impl serde::Serialize for TableSchema {
16475 #[allow(deprecated)]
16476 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16477 where
16478 S: serde::Serializer,
16479 {
16480 use serde::ser::SerializeStruct;
16481 let mut len = 0;
16482 if !self.column_ids.is_empty() {
16483 len += 1;
16484 }
16485 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
16486 if !self.column_ids.is_empty() {
16487 struct_ser.serialize_field("columnIds", &self.column_ids)?;
16488 }
16489 struct_ser.end()
16490 }
16491}
16492impl<'de> serde::Deserialize<'de> for TableSchema {
16493 #[allow(deprecated)]
16494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16495 where
16496 D: serde::Deserializer<'de>,
16497 {
16498 const FIELDS: &[&str] = &[
16499 "column_ids",
16500 "columnIds",
16501 ];
16502
16503 #[allow(clippy::enum_variant_names)]
16504 enum GeneratedField {
16505 ColumnIds,
16506 }
16507 impl<'de> serde::Deserialize<'de> for GeneratedField {
16508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16509 where
16510 D: serde::Deserializer<'de>,
16511 {
16512 struct GeneratedVisitor;
16513
16514 impl serde::de::Visitor<'_> for GeneratedVisitor {
16515 type Value = GeneratedField;
16516
16517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16518 write!(formatter, "expected one of: {:?}", &FIELDS)
16519 }
16520
16521 #[allow(unused_variables)]
16522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16523 where
16524 E: serde::de::Error,
16525 {
16526 match value {
16527 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
16528 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16529 }
16530 }
16531 }
16532 deserializer.deserialize_identifier(GeneratedVisitor)
16533 }
16534 }
16535 struct GeneratedVisitor;
16536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16537 type Value = TableSchema;
16538
16539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16540 formatter.write_str("struct hummock.TableSchema")
16541 }
16542
16543 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
16544 where
16545 V: serde::de::MapAccess<'de>,
16546 {
16547 let mut column_ids__ = None;
16548 while let Some(k) = map_.next_key()? {
16549 match k {
16550 GeneratedField::ColumnIds => {
16551 if column_ids__.is_some() {
16552 return Err(serde::de::Error::duplicate_field("columnIds"));
16553 }
16554 column_ids__ =
16555 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16556 .into_iter().map(|x| x.0).collect())
16557 ;
16558 }
16559 }
16560 }
16561 Ok(TableSchema {
16562 column_ids: column_ids__.unwrap_or_default(),
16563 })
16564 }
16565 }
16566 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
16567 }
16568}
16569impl serde::Serialize for TableStats {
16570 #[allow(deprecated)]
16571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16572 where
16573 S: serde::Serializer,
16574 {
16575 use serde::ser::SerializeStruct;
16576 let mut len = 0;
16577 if self.total_key_size != 0 {
16578 len += 1;
16579 }
16580 if self.total_value_size != 0 {
16581 len += 1;
16582 }
16583 if self.total_key_count != 0 {
16584 len += 1;
16585 }
16586 if self.total_compressed_size != 0 {
16587 len += 1;
16588 }
16589 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
16590 if self.total_key_size != 0 {
16591 #[allow(clippy::needless_borrow)]
16592 #[allow(clippy::needless_borrows_for_generic_args)]
16593 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
16594 }
16595 if self.total_value_size != 0 {
16596 #[allow(clippy::needless_borrow)]
16597 #[allow(clippy::needless_borrows_for_generic_args)]
16598 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
16599 }
16600 if self.total_key_count != 0 {
16601 #[allow(clippy::needless_borrow)]
16602 #[allow(clippy::needless_borrows_for_generic_args)]
16603 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
16604 }
16605 if self.total_compressed_size != 0 {
16606 #[allow(clippy::needless_borrow)]
16607 #[allow(clippy::needless_borrows_for_generic_args)]
16608 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
16609 }
16610 struct_ser.end()
16611 }
16612}
16613impl<'de> serde::Deserialize<'de> for TableStats {
16614 #[allow(deprecated)]
16615 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16616 where
16617 D: serde::Deserializer<'de>,
16618 {
16619 const FIELDS: &[&str] = &[
16620 "total_key_size",
16621 "totalKeySize",
16622 "total_value_size",
16623 "totalValueSize",
16624 "total_key_count",
16625 "totalKeyCount",
16626 "total_compressed_size",
16627 "totalCompressedSize",
16628 ];
16629
16630 #[allow(clippy::enum_variant_names)]
16631 enum GeneratedField {
16632 TotalKeySize,
16633 TotalValueSize,
16634 TotalKeyCount,
16635 TotalCompressedSize,
16636 }
16637 impl<'de> serde::Deserialize<'de> for GeneratedField {
16638 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16639 where
16640 D: serde::Deserializer<'de>,
16641 {
16642 struct GeneratedVisitor;
16643
16644 impl serde::de::Visitor<'_> for GeneratedVisitor {
16645 type Value = GeneratedField;
16646
16647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16648 write!(formatter, "expected one of: {:?}", &FIELDS)
16649 }
16650
16651 #[allow(unused_variables)]
16652 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16653 where
16654 E: serde::de::Error,
16655 {
16656 match value {
16657 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
16658 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
16659 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
16660 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
16661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16662 }
16663 }
16664 }
16665 deserializer.deserialize_identifier(GeneratedVisitor)
16666 }
16667 }
16668 struct GeneratedVisitor;
16669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16670 type Value = TableStats;
16671
16672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16673 formatter.write_str("struct hummock.TableStats")
16674 }
16675
16676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
16677 where
16678 V: serde::de::MapAccess<'de>,
16679 {
16680 let mut total_key_size__ = None;
16681 let mut total_value_size__ = None;
16682 let mut total_key_count__ = None;
16683 let mut total_compressed_size__ = None;
16684 while let Some(k) = map_.next_key()? {
16685 match k {
16686 GeneratedField::TotalKeySize => {
16687 if total_key_size__.is_some() {
16688 return Err(serde::de::Error::duplicate_field("totalKeySize"));
16689 }
16690 total_key_size__ =
16691 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16692 ;
16693 }
16694 GeneratedField::TotalValueSize => {
16695 if total_value_size__.is_some() {
16696 return Err(serde::de::Error::duplicate_field("totalValueSize"));
16697 }
16698 total_value_size__ =
16699 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16700 ;
16701 }
16702 GeneratedField::TotalKeyCount => {
16703 if total_key_count__.is_some() {
16704 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
16705 }
16706 total_key_count__ =
16707 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16708 ;
16709 }
16710 GeneratedField::TotalCompressedSize => {
16711 if total_compressed_size__.is_some() {
16712 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
16713 }
16714 total_compressed_size__ =
16715 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16716 ;
16717 }
16718 }
16719 }
16720 Ok(TableStats {
16721 total_key_size: total_key_size__.unwrap_or_default(),
16722 total_value_size: total_value_size__.unwrap_or_default(),
16723 total_key_count: total_key_count__.unwrap_or_default(),
16724 total_compressed_size: total_compressed_size__.unwrap_or_default(),
16725 })
16726 }
16727 }
16728 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
16729 }
16730}
16731impl serde::Serialize for TableWatermarks {
16732 #[allow(deprecated)]
16733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16734 where
16735 S: serde::Serializer,
16736 {
16737 use serde::ser::SerializeStruct;
16738 let mut len = 0;
16739 if !self.epoch_watermarks.is_empty() {
16740 len += 1;
16741 }
16742 if self.is_ascending {
16743 len += 1;
16744 }
16745 if self.is_non_pk_prefix {
16746 len += 1;
16747 }
16748 if self.raw_watermark_serde_type != 0 {
16749 len += 1;
16750 }
16751 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
16752 if !self.epoch_watermarks.is_empty() {
16753 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
16754 }
16755 if self.is_ascending {
16756 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
16757 }
16758 if self.is_non_pk_prefix {
16759 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
16760 }
16761 if self.raw_watermark_serde_type != 0 {
16762 let v = WatermarkSerdeType::try_from(self.raw_watermark_serde_type)
16763 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.raw_watermark_serde_type)))?;
16764 struct_ser.serialize_field("rawWatermarkSerdeType", &v)?;
16765 }
16766 struct_ser.end()
16767 }
16768}
16769impl<'de> serde::Deserialize<'de> for TableWatermarks {
16770 #[allow(deprecated)]
16771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16772 where
16773 D: serde::Deserializer<'de>,
16774 {
16775 const FIELDS: &[&str] = &[
16776 "epoch_watermarks",
16777 "epochWatermarks",
16778 "is_ascending",
16779 "isAscending",
16780 "is_non_pk_prefix",
16781 "isNonPkPrefix",
16782 "raw_watermark_serde_type",
16783 "rawWatermarkSerdeType",
16784 ];
16785
16786 #[allow(clippy::enum_variant_names)]
16787 enum GeneratedField {
16788 EpochWatermarks,
16789 IsAscending,
16790 IsNonPkPrefix,
16791 RawWatermarkSerdeType,
16792 }
16793 impl<'de> serde::Deserialize<'de> for GeneratedField {
16794 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16795 where
16796 D: serde::Deserializer<'de>,
16797 {
16798 struct GeneratedVisitor;
16799
16800 impl serde::de::Visitor<'_> for GeneratedVisitor {
16801 type Value = GeneratedField;
16802
16803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16804 write!(formatter, "expected one of: {:?}", &FIELDS)
16805 }
16806
16807 #[allow(unused_variables)]
16808 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16809 where
16810 E: serde::de::Error,
16811 {
16812 match value {
16813 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
16814 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
16815 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
16816 "rawWatermarkSerdeType" | "raw_watermark_serde_type" => Ok(GeneratedField::RawWatermarkSerdeType),
16817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16818 }
16819 }
16820 }
16821 deserializer.deserialize_identifier(GeneratedVisitor)
16822 }
16823 }
16824 struct GeneratedVisitor;
16825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16826 type Value = TableWatermarks;
16827
16828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16829 formatter.write_str("struct hummock.TableWatermarks")
16830 }
16831
16832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
16833 where
16834 V: serde::de::MapAccess<'de>,
16835 {
16836 let mut epoch_watermarks__ = None;
16837 let mut is_ascending__ = None;
16838 let mut is_non_pk_prefix__ = None;
16839 let mut raw_watermark_serde_type__ = None;
16840 while let Some(k) = map_.next_key()? {
16841 match k {
16842 GeneratedField::EpochWatermarks => {
16843 if epoch_watermarks__.is_some() {
16844 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
16845 }
16846 epoch_watermarks__ = Some(map_.next_value()?);
16847 }
16848 GeneratedField::IsAscending => {
16849 if is_ascending__.is_some() {
16850 return Err(serde::de::Error::duplicate_field("isAscending"));
16851 }
16852 is_ascending__ = Some(map_.next_value()?);
16853 }
16854 GeneratedField::IsNonPkPrefix => {
16855 if is_non_pk_prefix__.is_some() {
16856 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
16857 }
16858 is_non_pk_prefix__ = Some(map_.next_value()?);
16859 }
16860 GeneratedField::RawWatermarkSerdeType => {
16861 if raw_watermark_serde_type__.is_some() {
16862 return Err(serde::de::Error::duplicate_field("rawWatermarkSerdeType"));
16863 }
16864 raw_watermark_serde_type__ = Some(map_.next_value::<WatermarkSerdeType>()? as i32);
16865 }
16866 }
16867 }
16868 Ok(TableWatermarks {
16869 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
16870 is_ascending: is_ascending__.unwrap_or_default(),
16871 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
16872 raw_watermark_serde_type: raw_watermark_serde_type__.unwrap_or_default(),
16873 })
16874 }
16875 }
16876 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
16877 }
16878}
16879impl serde::Serialize for table_watermarks::EpochNewWatermarks {
16880 #[allow(deprecated)]
16881 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16882 where
16883 S: serde::Serializer,
16884 {
16885 use serde::ser::SerializeStruct;
16886 let mut len = 0;
16887 if !self.watermarks.is_empty() {
16888 len += 1;
16889 }
16890 if self.epoch != 0 {
16891 len += 1;
16892 }
16893 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
16894 if !self.watermarks.is_empty() {
16895 struct_ser.serialize_field("watermarks", &self.watermarks)?;
16896 }
16897 if self.epoch != 0 {
16898 #[allow(clippy::needless_borrow)]
16899 #[allow(clippy::needless_borrows_for_generic_args)]
16900 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
16901 }
16902 struct_ser.end()
16903 }
16904}
16905impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
16906 #[allow(deprecated)]
16907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16908 where
16909 D: serde::Deserializer<'de>,
16910 {
16911 const FIELDS: &[&str] = &[
16912 "watermarks",
16913 "epoch",
16914 ];
16915
16916 #[allow(clippy::enum_variant_names)]
16917 enum GeneratedField {
16918 Watermarks,
16919 Epoch,
16920 }
16921 impl<'de> serde::Deserialize<'de> for GeneratedField {
16922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16923 where
16924 D: serde::Deserializer<'de>,
16925 {
16926 struct GeneratedVisitor;
16927
16928 impl serde::de::Visitor<'_> for GeneratedVisitor {
16929 type Value = GeneratedField;
16930
16931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16932 write!(formatter, "expected one of: {:?}", &FIELDS)
16933 }
16934
16935 #[allow(unused_variables)]
16936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16937 where
16938 E: serde::de::Error,
16939 {
16940 match value {
16941 "watermarks" => Ok(GeneratedField::Watermarks),
16942 "epoch" => Ok(GeneratedField::Epoch),
16943 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16944 }
16945 }
16946 }
16947 deserializer.deserialize_identifier(GeneratedVisitor)
16948 }
16949 }
16950 struct GeneratedVisitor;
16951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16952 type Value = table_watermarks::EpochNewWatermarks;
16953
16954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16955 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
16956 }
16957
16958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
16959 where
16960 V: serde::de::MapAccess<'de>,
16961 {
16962 let mut watermarks__ = None;
16963 let mut epoch__ = None;
16964 while let Some(k) = map_.next_key()? {
16965 match k {
16966 GeneratedField::Watermarks => {
16967 if watermarks__.is_some() {
16968 return Err(serde::de::Error::duplicate_field("watermarks"));
16969 }
16970 watermarks__ = Some(map_.next_value()?);
16971 }
16972 GeneratedField::Epoch => {
16973 if epoch__.is_some() {
16974 return Err(serde::de::Error::duplicate_field("epoch"));
16975 }
16976 epoch__ =
16977 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16978 ;
16979 }
16980 }
16981 }
16982 Ok(table_watermarks::EpochNewWatermarks {
16983 watermarks: watermarks__.unwrap_or_default(),
16984 epoch: epoch__.unwrap_or_default(),
16985 })
16986 }
16987 }
16988 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
16989 }
16990}
16991impl serde::Serialize for TriggerCompactionDeterministicRequest {
16992 #[allow(deprecated)]
16993 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16994 where
16995 S: serde::Serializer,
16996 {
16997 use serde::ser::SerializeStruct;
16998 let mut len = 0;
16999 if self.version_id != 0 {
17000 len += 1;
17001 }
17002 if !self.compaction_groups.is_empty() {
17003 len += 1;
17004 }
17005 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
17006 if self.version_id != 0 {
17007 #[allow(clippy::needless_borrow)]
17008 #[allow(clippy::needless_borrows_for_generic_args)]
17009 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
17010 }
17011 if !self.compaction_groups.is_empty() {
17012 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
17013 }
17014 struct_ser.end()
17015 }
17016}
17017impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
17018 #[allow(deprecated)]
17019 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17020 where
17021 D: serde::Deserializer<'de>,
17022 {
17023 const FIELDS: &[&str] = &[
17024 "version_id",
17025 "versionId",
17026 "compaction_groups",
17027 "compactionGroups",
17028 ];
17029
17030 #[allow(clippy::enum_variant_names)]
17031 enum GeneratedField {
17032 VersionId,
17033 CompactionGroups,
17034 }
17035 impl<'de> serde::Deserialize<'de> for GeneratedField {
17036 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17037 where
17038 D: serde::Deserializer<'de>,
17039 {
17040 struct GeneratedVisitor;
17041
17042 impl serde::de::Visitor<'_> for GeneratedVisitor {
17043 type Value = GeneratedField;
17044
17045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17046 write!(formatter, "expected one of: {:?}", &FIELDS)
17047 }
17048
17049 #[allow(unused_variables)]
17050 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17051 where
17052 E: serde::de::Error,
17053 {
17054 match value {
17055 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
17056 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
17057 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17058 }
17059 }
17060 }
17061 deserializer.deserialize_identifier(GeneratedVisitor)
17062 }
17063 }
17064 struct GeneratedVisitor;
17065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17066 type Value = TriggerCompactionDeterministicRequest;
17067
17068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17069 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
17070 }
17071
17072 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
17073 where
17074 V: serde::de::MapAccess<'de>,
17075 {
17076 let mut version_id__ = None;
17077 let mut compaction_groups__ = None;
17078 while let Some(k) = map_.next_key()? {
17079 match k {
17080 GeneratedField::VersionId => {
17081 if version_id__.is_some() {
17082 return Err(serde::de::Error::duplicate_field("versionId"));
17083 }
17084 version_id__ =
17085 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17086 ;
17087 }
17088 GeneratedField::CompactionGroups => {
17089 if compaction_groups__.is_some() {
17090 return Err(serde::de::Error::duplicate_field("compactionGroups"));
17091 }
17092 compaction_groups__ =
17093 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17094 .into_iter().map(|x| x.0).collect())
17095 ;
17096 }
17097 }
17098 }
17099 Ok(TriggerCompactionDeterministicRequest {
17100 version_id: version_id__.unwrap_or_default(),
17101 compaction_groups: compaction_groups__.unwrap_or_default(),
17102 })
17103 }
17104 }
17105 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
17106 }
17107}
17108impl serde::Serialize for TriggerCompactionDeterministicResponse {
17109 #[allow(deprecated)]
17110 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17111 where
17112 S: serde::Serializer,
17113 {
17114 use serde::ser::SerializeStruct;
17115 let len = 0;
17116 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
17117 struct_ser.end()
17118 }
17119}
17120impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
17121 #[allow(deprecated)]
17122 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17123 where
17124 D: serde::Deserializer<'de>,
17125 {
17126 const FIELDS: &[&str] = &[
17127 ];
17128
17129 #[allow(clippy::enum_variant_names)]
17130 enum GeneratedField {
17131 }
17132 impl<'de> serde::Deserialize<'de> for GeneratedField {
17133 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17134 where
17135 D: serde::Deserializer<'de>,
17136 {
17137 struct GeneratedVisitor;
17138
17139 impl serde::de::Visitor<'_> for GeneratedVisitor {
17140 type Value = GeneratedField;
17141
17142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17143 write!(formatter, "expected one of: {:?}", &FIELDS)
17144 }
17145
17146 #[allow(unused_variables)]
17147 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17148 where
17149 E: serde::de::Error,
17150 {
17151 Err(serde::de::Error::unknown_field(value, FIELDS))
17152 }
17153 }
17154 deserializer.deserialize_identifier(GeneratedVisitor)
17155 }
17156 }
17157 struct GeneratedVisitor;
17158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17159 type Value = TriggerCompactionDeterministicResponse;
17160
17161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17162 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
17163 }
17164
17165 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
17166 where
17167 V: serde::de::MapAccess<'de>,
17168 {
17169 while map_.next_key::<GeneratedField>()?.is_some() {
17170 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17171 }
17172 Ok(TriggerCompactionDeterministicResponse {
17173 })
17174 }
17175 }
17176 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
17177 }
17178}
17179impl serde::Serialize for TriggerFullGcRequest {
17180 #[allow(deprecated)]
17181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17182 where
17183 S: serde::Serializer,
17184 {
17185 use serde::ser::SerializeStruct;
17186 let mut len = 0;
17187 if self.sst_retention_time_sec != 0 {
17188 len += 1;
17189 }
17190 if self.prefix.is_some() {
17191 len += 1;
17192 }
17193 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
17194 if self.sst_retention_time_sec != 0 {
17195 #[allow(clippy::needless_borrow)]
17196 #[allow(clippy::needless_borrows_for_generic_args)]
17197 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
17198 }
17199 if let Some(v) = self.prefix.as_ref() {
17200 struct_ser.serialize_field("prefix", v)?;
17201 }
17202 struct_ser.end()
17203 }
17204}
17205impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
17206 #[allow(deprecated)]
17207 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17208 where
17209 D: serde::Deserializer<'de>,
17210 {
17211 const FIELDS: &[&str] = &[
17212 "sst_retention_time_sec",
17213 "sstRetentionTimeSec",
17214 "prefix",
17215 ];
17216
17217 #[allow(clippy::enum_variant_names)]
17218 enum GeneratedField {
17219 SstRetentionTimeSec,
17220 Prefix,
17221 }
17222 impl<'de> serde::Deserialize<'de> for GeneratedField {
17223 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17224 where
17225 D: serde::Deserializer<'de>,
17226 {
17227 struct GeneratedVisitor;
17228
17229 impl serde::de::Visitor<'_> for GeneratedVisitor {
17230 type Value = GeneratedField;
17231
17232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17233 write!(formatter, "expected one of: {:?}", &FIELDS)
17234 }
17235
17236 #[allow(unused_variables)]
17237 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17238 where
17239 E: serde::de::Error,
17240 {
17241 match value {
17242 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
17243 "prefix" => Ok(GeneratedField::Prefix),
17244 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17245 }
17246 }
17247 }
17248 deserializer.deserialize_identifier(GeneratedVisitor)
17249 }
17250 }
17251 struct GeneratedVisitor;
17252 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17253 type Value = TriggerFullGcRequest;
17254
17255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17256 formatter.write_str("struct hummock.TriggerFullGCRequest")
17257 }
17258
17259 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
17260 where
17261 V: serde::de::MapAccess<'de>,
17262 {
17263 let mut sst_retention_time_sec__ = None;
17264 let mut prefix__ = None;
17265 while let Some(k) = map_.next_key()? {
17266 match k {
17267 GeneratedField::SstRetentionTimeSec => {
17268 if sst_retention_time_sec__.is_some() {
17269 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
17270 }
17271 sst_retention_time_sec__ =
17272 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17273 ;
17274 }
17275 GeneratedField::Prefix => {
17276 if prefix__.is_some() {
17277 return Err(serde::de::Error::duplicate_field("prefix"));
17278 }
17279 prefix__ = map_.next_value()?;
17280 }
17281 }
17282 }
17283 Ok(TriggerFullGcRequest {
17284 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
17285 prefix: prefix__,
17286 })
17287 }
17288 }
17289 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
17290 }
17291}
17292impl serde::Serialize for TriggerFullGcResponse {
17293 #[allow(deprecated)]
17294 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17295 where
17296 S: serde::Serializer,
17297 {
17298 use serde::ser::SerializeStruct;
17299 let mut len = 0;
17300 if self.status.is_some() {
17301 len += 1;
17302 }
17303 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
17304 if let Some(v) = self.status.as_ref() {
17305 struct_ser.serialize_field("status", v)?;
17306 }
17307 struct_ser.end()
17308 }
17309}
17310impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
17311 #[allow(deprecated)]
17312 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17313 where
17314 D: serde::Deserializer<'de>,
17315 {
17316 const FIELDS: &[&str] = &[
17317 "status",
17318 ];
17319
17320 #[allow(clippy::enum_variant_names)]
17321 enum GeneratedField {
17322 Status,
17323 }
17324 impl<'de> serde::Deserialize<'de> for GeneratedField {
17325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17326 where
17327 D: serde::Deserializer<'de>,
17328 {
17329 struct GeneratedVisitor;
17330
17331 impl serde::de::Visitor<'_> for GeneratedVisitor {
17332 type Value = GeneratedField;
17333
17334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17335 write!(formatter, "expected one of: {:?}", &FIELDS)
17336 }
17337
17338 #[allow(unused_variables)]
17339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17340 where
17341 E: serde::de::Error,
17342 {
17343 match value {
17344 "status" => Ok(GeneratedField::Status),
17345 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17346 }
17347 }
17348 }
17349 deserializer.deserialize_identifier(GeneratedVisitor)
17350 }
17351 }
17352 struct GeneratedVisitor;
17353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17354 type Value = TriggerFullGcResponse;
17355
17356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17357 formatter.write_str("struct hummock.TriggerFullGCResponse")
17358 }
17359
17360 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
17361 where
17362 V: serde::de::MapAccess<'de>,
17363 {
17364 let mut status__ = None;
17365 while let Some(k) = map_.next_key()? {
17366 match k {
17367 GeneratedField::Status => {
17368 if status__.is_some() {
17369 return Err(serde::de::Error::duplicate_field("status"));
17370 }
17371 status__ = map_.next_value()?;
17372 }
17373 }
17374 }
17375 Ok(TriggerFullGcResponse {
17376 status: status__,
17377 })
17378 }
17379 }
17380 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
17381 }
17382}
17383impl serde::Serialize for TriggerManualCompactionRequest {
17384 #[allow(deprecated)]
17385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17386 where
17387 S: serde::Serializer,
17388 {
17389 use serde::ser::SerializeStruct;
17390 let mut len = 0;
17391 if self.compaction_group_id != 0 {
17392 len += 1;
17393 }
17394 if self.key_range.is_some() {
17395 len += 1;
17396 }
17397 if self.table_id != 0 {
17398 len += 1;
17399 }
17400 if self.level != 0 {
17401 len += 1;
17402 }
17403 if !self.sst_ids.is_empty() {
17404 len += 1;
17405 }
17406 if self.exclusive.is_some() {
17407 len += 1;
17408 }
17409 if self.target_level.is_some() {
17410 len += 1;
17411 }
17412 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
17413 if self.compaction_group_id != 0 {
17414 #[allow(clippy::needless_borrow)]
17415 #[allow(clippy::needless_borrows_for_generic_args)]
17416 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
17417 }
17418 if let Some(v) = self.key_range.as_ref() {
17419 struct_ser.serialize_field("keyRange", v)?;
17420 }
17421 if self.table_id != 0 {
17422 struct_ser.serialize_field("tableId", &self.table_id)?;
17423 }
17424 if self.level != 0 {
17425 struct_ser.serialize_field("level", &self.level)?;
17426 }
17427 if !self.sst_ids.is_empty() {
17428 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
17429 }
17430 if let Some(v) = self.exclusive.as_ref() {
17431 struct_ser.serialize_field("exclusive", v)?;
17432 }
17433 if let Some(v) = self.target_level.as_ref() {
17434 struct_ser.serialize_field("targetLevel", v)?;
17435 }
17436 struct_ser.end()
17437 }
17438}
17439impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
17440 #[allow(deprecated)]
17441 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17442 where
17443 D: serde::Deserializer<'de>,
17444 {
17445 const FIELDS: &[&str] = &[
17446 "compaction_group_id",
17447 "compactionGroupId",
17448 "key_range",
17449 "keyRange",
17450 "table_id",
17451 "tableId",
17452 "level",
17453 "sst_ids",
17454 "sstIds",
17455 "exclusive",
17456 "target_level",
17457 "targetLevel",
17458 ];
17459
17460 #[allow(clippy::enum_variant_names)]
17461 enum GeneratedField {
17462 CompactionGroupId,
17463 KeyRange,
17464 TableId,
17465 Level,
17466 SstIds,
17467 Exclusive,
17468 TargetLevel,
17469 }
17470 impl<'de> serde::Deserialize<'de> for GeneratedField {
17471 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17472 where
17473 D: serde::Deserializer<'de>,
17474 {
17475 struct GeneratedVisitor;
17476
17477 impl serde::de::Visitor<'_> for GeneratedVisitor {
17478 type Value = GeneratedField;
17479
17480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17481 write!(formatter, "expected one of: {:?}", &FIELDS)
17482 }
17483
17484 #[allow(unused_variables)]
17485 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17486 where
17487 E: serde::de::Error,
17488 {
17489 match value {
17490 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
17491 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
17492 "tableId" | "table_id" => Ok(GeneratedField::TableId),
17493 "level" => Ok(GeneratedField::Level),
17494 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
17495 "exclusive" => Ok(GeneratedField::Exclusive),
17496 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
17497 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17498 }
17499 }
17500 }
17501 deserializer.deserialize_identifier(GeneratedVisitor)
17502 }
17503 }
17504 struct GeneratedVisitor;
17505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17506 type Value = TriggerManualCompactionRequest;
17507
17508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17509 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
17510 }
17511
17512 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
17513 where
17514 V: serde::de::MapAccess<'de>,
17515 {
17516 let mut compaction_group_id__ = None;
17517 let mut key_range__ = None;
17518 let mut table_id__ = None;
17519 let mut level__ = None;
17520 let mut sst_ids__ = None;
17521 let mut exclusive__ = None;
17522 let mut target_level__ = None;
17523 while let Some(k) = map_.next_key()? {
17524 match k {
17525 GeneratedField::CompactionGroupId => {
17526 if compaction_group_id__.is_some() {
17527 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
17528 }
17529 compaction_group_id__ =
17530 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17531 ;
17532 }
17533 GeneratedField::KeyRange => {
17534 if key_range__.is_some() {
17535 return Err(serde::de::Error::duplicate_field("keyRange"));
17536 }
17537 key_range__ = map_.next_value()?;
17538 }
17539 GeneratedField::TableId => {
17540 if table_id__.is_some() {
17541 return Err(serde::de::Error::duplicate_field("tableId"));
17542 }
17543 table_id__ =
17544 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17545 ;
17546 }
17547 GeneratedField::Level => {
17548 if level__.is_some() {
17549 return Err(serde::de::Error::duplicate_field("level"));
17550 }
17551 level__ =
17552 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17553 ;
17554 }
17555 GeneratedField::SstIds => {
17556 if sst_ids__.is_some() {
17557 return Err(serde::de::Error::duplicate_field("sstIds"));
17558 }
17559 sst_ids__ =
17560 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17561 .into_iter().map(|x| x.0).collect())
17562 ;
17563 }
17564 GeneratedField::Exclusive => {
17565 if exclusive__.is_some() {
17566 return Err(serde::de::Error::duplicate_field("exclusive"));
17567 }
17568 exclusive__ = map_.next_value()?;
17569 }
17570 GeneratedField::TargetLevel => {
17571 if target_level__.is_some() {
17572 return Err(serde::de::Error::duplicate_field("targetLevel"));
17573 }
17574 target_level__ =
17575 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17576 ;
17577 }
17578 }
17579 }
17580 Ok(TriggerManualCompactionRequest {
17581 compaction_group_id: compaction_group_id__.unwrap_or_default(),
17582 key_range: key_range__,
17583 table_id: table_id__.unwrap_or_default(),
17584 level: level__.unwrap_or_default(),
17585 sst_ids: sst_ids__.unwrap_or_default(),
17586 exclusive: exclusive__,
17587 target_level: target_level__,
17588 })
17589 }
17590 }
17591 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
17592 }
17593}
17594impl serde::Serialize for TriggerManualCompactionResponse {
17595 #[allow(deprecated)]
17596 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17597 where
17598 S: serde::Serializer,
17599 {
17600 use serde::ser::SerializeStruct;
17601 let mut len = 0;
17602 if self.status.is_some() {
17603 len += 1;
17604 }
17605 if self.should_retry.is_some() {
17606 len += 1;
17607 }
17608 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
17609 if let Some(v) = self.status.as_ref() {
17610 struct_ser.serialize_field("status", v)?;
17611 }
17612 if let Some(v) = self.should_retry.as_ref() {
17613 struct_ser.serialize_field("shouldRetry", v)?;
17614 }
17615 struct_ser.end()
17616 }
17617}
17618impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
17619 #[allow(deprecated)]
17620 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17621 where
17622 D: serde::Deserializer<'de>,
17623 {
17624 const FIELDS: &[&str] = &[
17625 "status",
17626 "should_retry",
17627 "shouldRetry",
17628 ];
17629
17630 #[allow(clippy::enum_variant_names)]
17631 enum GeneratedField {
17632 Status,
17633 ShouldRetry,
17634 }
17635 impl<'de> serde::Deserialize<'de> for GeneratedField {
17636 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17637 where
17638 D: serde::Deserializer<'de>,
17639 {
17640 struct GeneratedVisitor;
17641
17642 impl serde::de::Visitor<'_> for GeneratedVisitor {
17643 type Value = GeneratedField;
17644
17645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17646 write!(formatter, "expected one of: {:?}", &FIELDS)
17647 }
17648
17649 #[allow(unused_variables)]
17650 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17651 where
17652 E: serde::de::Error,
17653 {
17654 match value {
17655 "status" => Ok(GeneratedField::Status),
17656 "shouldRetry" | "should_retry" => Ok(GeneratedField::ShouldRetry),
17657 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17658 }
17659 }
17660 }
17661 deserializer.deserialize_identifier(GeneratedVisitor)
17662 }
17663 }
17664 struct GeneratedVisitor;
17665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17666 type Value = TriggerManualCompactionResponse;
17667
17668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17669 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
17670 }
17671
17672 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
17673 where
17674 V: serde::de::MapAccess<'de>,
17675 {
17676 let mut status__ = None;
17677 let mut should_retry__ = None;
17678 while let Some(k) = map_.next_key()? {
17679 match k {
17680 GeneratedField::Status => {
17681 if status__.is_some() {
17682 return Err(serde::de::Error::duplicate_field("status"));
17683 }
17684 status__ = map_.next_value()?;
17685 }
17686 GeneratedField::ShouldRetry => {
17687 if should_retry__.is_some() {
17688 return Err(serde::de::Error::duplicate_field("shouldRetry"));
17689 }
17690 should_retry__ = map_.next_value()?;
17691 }
17692 }
17693 }
17694 Ok(TriggerManualCompactionResponse {
17695 status: status__,
17696 should_retry: should_retry__,
17697 })
17698 }
17699 }
17700 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
17701 }
17702}
17703impl serde::Serialize for TruncateTables {
17704 #[allow(deprecated)]
17705 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17706 where
17707 S: serde::Serializer,
17708 {
17709 use serde::ser::SerializeStruct;
17710 let mut len = 0;
17711 if !self.table_ids.is_empty() {
17712 len += 1;
17713 }
17714 let mut struct_ser = serializer.serialize_struct("hummock.TruncateTables", len)?;
17715 if !self.table_ids.is_empty() {
17716 struct_ser.serialize_field("tableIds", &self.table_ids)?;
17717 }
17718 struct_ser.end()
17719 }
17720}
17721impl<'de> serde::Deserialize<'de> for TruncateTables {
17722 #[allow(deprecated)]
17723 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17724 where
17725 D: serde::Deserializer<'de>,
17726 {
17727 const FIELDS: &[&str] = &[
17728 "table_ids",
17729 "tableIds",
17730 ];
17731
17732 #[allow(clippy::enum_variant_names)]
17733 enum GeneratedField {
17734 TableIds,
17735 }
17736 impl<'de> serde::Deserialize<'de> for GeneratedField {
17737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17738 where
17739 D: serde::Deserializer<'de>,
17740 {
17741 struct GeneratedVisitor;
17742
17743 impl serde::de::Visitor<'_> for GeneratedVisitor {
17744 type Value = GeneratedField;
17745
17746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17747 write!(formatter, "expected one of: {:?}", &FIELDS)
17748 }
17749
17750 #[allow(unused_variables)]
17751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17752 where
17753 E: serde::de::Error,
17754 {
17755 match value {
17756 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
17757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17758 }
17759 }
17760 }
17761 deserializer.deserialize_identifier(GeneratedVisitor)
17762 }
17763 }
17764 struct GeneratedVisitor;
17765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17766 type Value = TruncateTables;
17767
17768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17769 formatter.write_str("struct hummock.TruncateTables")
17770 }
17771
17772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TruncateTables, V::Error>
17773 where
17774 V: serde::de::MapAccess<'de>,
17775 {
17776 let mut table_ids__ = None;
17777 while let Some(k) = map_.next_key()? {
17778 match k {
17779 GeneratedField::TableIds => {
17780 if table_ids__.is_some() {
17781 return Err(serde::de::Error::duplicate_field("tableIds"));
17782 }
17783 table_ids__ =
17784 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17785 .into_iter().map(|x| x.0).collect())
17786 ;
17787 }
17788 }
17789 }
17790 Ok(TruncateTables {
17791 table_ids: table_ids__.unwrap_or_default(),
17792 })
17793 }
17794 }
17795 deserializer.deserialize_struct("hummock.TruncateTables", FIELDS, GeneratedVisitor)
17796 }
17797}
17798impl serde::Serialize for UnpinVersionBeforeRequest {
17799 #[allow(deprecated)]
17800 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17801 where
17802 S: serde::Serializer,
17803 {
17804 use serde::ser::SerializeStruct;
17805 let mut len = 0;
17806 if self.context_id != 0 {
17807 len += 1;
17808 }
17809 if self.unpin_version_before != 0 {
17810 len += 1;
17811 }
17812 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
17813 if self.context_id != 0 {
17814 struct_ser.serialize_field("contextId", &self.context_id)?;
17815 }
17816 if self.unpin_version_before != 0 {
17817 #[allow(clippy::needless_borrow)]
17818 #[allow(clippy::needless_borrows_for_generic_args)]
17819 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
17820 }
17821 struct_ser.end()
17822 }
17823}
17824impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
17825 #[allow(deprecated)]
17826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17827 where
17828 D: serde::Deserializer<'de>,
17829 {
17830 const FIELDS: &[&str] = &[
17831 "context_id",
17832 "contextId",
17833 "unpin_version_before",
17834 "unpinVersionBefore",
17835 ];
17836
17837 #[allow(clippy::enum_variant_names)]
17838 enum GeneratedField {
17839 ContextId,
17840 UnpinVersionBefore,
17841 }
17842 impl<'de> serde::Deserialize<'de> for GeneratedField {
17843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17844 where
17845 D: serde::Deserializer<'de>,
17846 {
17847 struct GeneratedVisitor;
17848
17849 impl serde::de::Visitor<'_> for GeneratedVisitor {
17850 type Value = GeneratedField;
17851
17852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17853 write!(formatter, "expected one of: {:?}", &FIELDS)
17854 }
17855
17856 #[allow(unused_variables)]
17857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17858 where
17859 E: serde::de::Error,
17860 {
17861 match value {
17862 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
17863 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
17864 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17865 }
17866 }
17867 }
17868 deserializer.deserialize_identifier(GeneratedVisitor)
17869 }
17870 }
17871 struct GeneratedVisitor;
17872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17873 type Value = UnpinVersionBeforeRequest;
17874
17875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17876 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
17877 }
17878
17879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
17880 where
17881 V: serde::de::MapAccess<'de>,
17882 {
17883 let mut context_id__ = None;
17884 let mut unpin_version_before__ = None;
17885 while let Some(k) = map_.next_key()? {
17886 match k {
17887 GeneratedField::ContextId => {
17888 if context_id__.is_some() {
17889 return Err(serde::de::Error::duplicate_field("contextId"));
17890 }
17891 context_id__ =
17892 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17893 ;
17894 }
17895 GeneratedField::UnpinVersionBefore => {
17896 if unpin_version_before__.is_some() {
17897 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
17898 }
17899 unpin_version_before__ =
17900 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17901 ;
17902 }
17903 }
17904 }
17905 Ok(UnpinVersionBeforeRequest {
17906 context_id: context_id__.unwrap_or_default(),
17907 unpin_version_before: unpin_version_before__.unwrap_or_default(),
17908 })
17909 }
17910 }
17911 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
17912 }
17913}
17914impl serde::Serialize for UnpinVersionBeforeResponse {
17915 #[allow(deprecated)]
17916 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17917 where
17918 S: serde::Serializer,
17919 {
17920 use serde::ser::SerializeStruct;
17921 let mut len = 0;
17922 if self.status.is_some() {
17923 len += 1;
17924 }
17925 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
17926 if let Some(v) = self.status.as_ref() {
17927 struct_ser.serialize_field("status", v)?;
17928 }
17929 struct_ser.end()
17930 }
17931}
17932impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
17933 #[allow(deprecated)]
17934 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17935 where
17936 D: serde::Deserializer<'de>,
17937 {
17938 const FIELDS: &[&str] = &[
17939 "status",
17940 ];
17941
17942 #[allow(clippy::enum_variant_names)]
17943 enum GeneratedField {
17944 Status,
17945 }
17946 impl<'de> serde::Deserialize<'de> for GeneratedField {
17947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17948 where
17949 D: serde::Deserializer<'de>,
17950 {
17951 struct GeneratedVisitor;
17952
17953 impl serde::de::Visitor<'_> for GeneratedVisitor {
17954 type Value = GeneratedField;
17955
17956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17957 write!(formatter, "expected one of: {:?}", &FIELDS)
17958 }
17959
17960 #[allow(unused_variables)]
17961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17962 where
17963 E: serde::de::Error,
17964 {
17965 match value {
17966 "status" => Ok(GeneratedField::Status),
17967 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17968 }
17969 }
17970 }
17971 deserializer.deserialize_identifier(GeneratedVisitor)
17972 }
17973 }
17974 struct GeneratedVisitor;
17975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17976 type Value = UnpinVersionBeforeResponse;
17977
17978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17979 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
17980 }
17981
17982 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
17983 where
17984 V: serde::de::MapAccess<'de>,
17985 {
17986 let mut status__ = None;
17987 while let Some(k) = map_.next_key()? {
17988 match k {
17989 GeneratedField::Status => {
17990 if status__.is_some() {
17991 return Err(serde::de::Error::duplicate_field("status"));
17992 }
17993 status__ = map_.next_value()?;
17994 }
17995 }
17996 }
17997 Ok(UnpinVersionBeforeResponse {
17998 status: status__,
17999 })
18000 }
18001 }
18002 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
18003 }
18004}
18005impl serde::Serialize for UnpinVersionRequest {
18006 #[allow(deprecated)]
18007 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18008 where
18009 S: serde::Serializer,
18010 {
18011 use serde::ser::SerializeStruct;
18012 let mut len = 0;
18013 if self.context_id != 0 {
18014 len += 1;
18015 }
18016 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
18017 if self.context_id != 0 {
18018 struct_ser.serialize_field("contextId", &self.context_id)?;
18019 }
18020 struct_ser.end()
18021 }
18022}
18023impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
18024 #[allow(deprecated)]
18025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18026 where
18027 D: serde::Deserializer<'de>,
18028 {
18029 const FIELDS: &[&str] = &[
18030 "context_id",
18031 "contextId",
18032 ];
18033
18034 #[allow(clippy::enum_variant_names)]
18035 enum GeneratedField {
18036 ContextId,
18037 }
18038 impl<'de> serde::Deserialize<'de> for GeneratedField {
18039 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18040 where
18041 D: serde::Deserializer<'de>,
18042 {
18043 struct GeneratedVisitor;
18044
18045 impl serde::de::Visitor<'_> for GeneratedVisitor {
18046 type Value = GeneratedField;
18047
18048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18049 write!(formatter, "expected one of: {:?}", &FIELDS)
18050 }
18051
18052 #[allow(unused_variables)]
18053 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18054 where
18055 E: serde::de::Error,
18056 {
18057 match value {
18058 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
18059 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18060 }
18061 }
18062 }
18063 deserializer.deserialize_identifier(GeneratedVisitor)
18064 }
18065 }
18066 struct GeneratedVisitor;
18067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18068 type Value = UnpinVersionRequest;
18069
18070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18071 formatter.write_str("struct hummock.UnpinVersionRequest")
18072 }
18073
18074 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
18075 where
18076 V: serde::de::MapAccess<'de>,
18077 {
18078 let mut context_id__ = None;
18079 while let Some(k) = map_.next_key()? {
18080 match k {
18081 GeneratedField::ContextId => {
18082 if context_id__.is_some() {
18083 return Err(serde::de::Error::duplicate_field("contextId"));
18084 }
18085 context_id__ =
18086 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18087 ;
18088 }
18089 }
18090 }
18091 Ok(UnpinVersionRequest {
18092 context_id: context_id__.unwrap_or_default(),
18093 })
18094 }
18095 }
18096 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
18097 }
18098}
18099impl serde::Serialize for UnpinVersionResponse {
18100 #[allow(deprecated)]
18101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18102 where
18103 S: serde::Serializer,
18104 {
18105 use serde::ser::SerializeStruct;
18106 let mut len = 0;
18107 if self.status.is_some() {
18108 len += 1;
18109 }
18110 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
18111 if let Some(v) = self.status.as_ref() {
18112 struct_ser.serialize_field("status", v)?;
18113 }
18114 struct_ser.end()
18115 }
18116}
18117impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
18118 #[allow(deprecated)]
18119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18120 where
18121 D: serde::Deserializer<'de>,
18122 {
18123 const FIELDS: &[&str] = &[
18124 "status",
18125 ];
18126
18127 #[allow(clippy::enum_variant_names)]
18128 enum GeneratedField {
18129 Status,
18130 }
18131 impl<'de> serde::Deserialize<'de> for GeneratedField {
18132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18133 where
18134 D: serde::Deserializer<'de>,
18135 {
18136 struct GeneratedVisitor;
18137
18138 impl serde::de::Visitor<'_> for GeneratedVisitor {
18139 type Value = GeneratedField;
18140
18141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18142 write!(formatter, "expected one of: {:?}", &FIELDS)
18143 }
18144
18145 #[allow(unused_variables)]
18146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18147 where
18148 E: serde::de::Error,
18149 {
18150 match value {
18151 "status" => Ok(GeneratedField::Status),
18152 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18153 }
18154 }
18155 }
18156 deserializer.deserialize_identifier(GeneratedVisitor)
18157 }
18158 }
18159 struct GeneratedVisitor;
18160 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18161 type Value = UnpinVersionResponse;
18162
18163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18164 formatter.write_str("struct hummock.UnpinVersionResponse")
18165 }
18166
18167 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
18168 where
18169 V: serde::de::MapAccess<'de>,
18170 {
18171 let mut status__ = None;
18172 while let Some(k) = map_.next_key()? {
18173 match k {
18174 GeneratedField::Status => {
18175 if status__.is_some() {
18176 return Err(serde::de::Error::duplicate_field("status"));
18177 }
18178 status__ = map_.next_value()?;
18179 }
18180 }
18181 }
18182 Ok(UnpinVersionResponse {
18183 status: status__,
18184 })
18185 }
18186 }
18187 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
18188 }
18189}
18190impl serde::Serialize for VacuumTask {
18191 #[allow(deprecated)]
18192 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18193 where
18194 S: serde::Serializer,
18195 {
18196 use serde::ser::SerializeStruct;
18197 let mut len = 0;
18198 if !self.sstable_object_ids.is_empty() {
18199 len += 1;
18200 }
18201 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
18202 if !self.sstable_object_ids.is_empty() {
18203 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
18204 }
18205 struct_ser.end()
18206 }
18207}
18208impl<'de> serde::Deserialize<'de> for VacuumTask {
18209 #[allow(deprecated)]
18210 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18211 where
18212 D: serde::Deserializer<'de>,
18213 {
18214 const FIELDS: &[&str] = &[
18215 "sstable_object_ids",
18216 "sstableObjectIds",
18217 ];
18218
18219 #[allow(clippy::enum_variant_names)]
18220 enum GeneratedField {
18221 SstableObjectIds,
18222 }
18223 impl<'de> serde::Deserialize<'de> for GeneratedField {
18224 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18225 where
18226 D: serde::Deserializer<'de>,
18227 {
18228 struct GeneratedVisitor;
18229
18230 impl serde::de::Visitor<'_> for GeneratedVisitor {
18231 type Value = GeneratedField;
18232
18233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18234 write!(formatter, "expected one of: {:?}", &FIELDS)
18235 }
18236
18237 #[allow(unused_variables)]
18238 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18239 where
18240 E: serde::de::Error,
18241 {
18242 match value {
18243 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
18244 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18245 }
18246 }
18247 }
18248 deserializer.deserialize_identifier(GeneratedVisitor)
18249 }
18250 }
18251 struct GeneratedVisitor;
18252 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18253 type Value = VacuumTask;
18254
18255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18256 formatter.write_str("struct hummock.VacuumTask")
18257 }
18258
18259 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
18260 where
18261 V: serde::de::MapAccess<'de>,
18262 {
18263 let mut sstable_object_ids__ = None;
18264 while let Some(k) = map_.next_key()? {
18265 match k {
18266 GeneratedField::SstableObjectIds => {
18267 if sstable_object_ids__.is_some() {
18268 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
18269 }
18270 sstable_object_ids__ =
18271 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18272 .into_iter().map(|x| x.0).collect())
18273 ;
18274 }
18275 }
18276 }
18277 Ok(VacuumTask {
18278 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
18279 })
18280 }
18281 }
18282 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
18283 }
18284}
18285impl serde::Serialize for ValidationTask {
18286 #[allow(deprecated)]
18287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18288 where
18289 S: serde::Serializer,
18290 {
18291 use serde::ser::SerializeStruct;
18292 let mut len = 0;
18293 if !self.sst_infos.is_empty() {
18294 len += 1;
18295 }
18296 if !self.sst_id_to_worker_id.is_empty() {
18297 len += 1;
18298 }
18299 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
18300 if !self.sst_infos.is_empty() {
18301 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
18302 }
18303 if !self.sst_id_to_worker_id.is_empty() {
18304 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
18305 }
18306 struct_ser.end()
18307 }
18308}
18309impl<'de> serde::Deserialize<'de> for ValidationTask {
18310 #[allow(deprecated)]
18311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18312 where
18313 D: serde::Deserializer<'de>,
18314 {
18315 const FIELDS: &[&str] = &[
18316 "sst_infos",
18317 "sstInfos",
18318 "sst_id_to_worker_id",
18319 "sstIdToWorkerId",
18320 ];
18321
18322 #[allow(clippy::enum_variant_names)]
18323 enum GeneratedField {
18324 SstInfos,
18325 SstIdToWorkerId,
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 serde::de::Visitor<'_> 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 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
18348 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
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 = ValidationTask;
18359
18360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18361 formatter.write_str("struct hummock.ValidationTask")
18362 }
18363
18364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
18365 where
18366 V: serde::de::MapAccess<'de>,
18367 {
18368 let mut sst_infos__ = None;
18369 let mut sst_id_to_worker_id__ = None;
18370 while let Some(k) = map_.next_key()? {
18371 match k {
18372 GeneratedField::SstInfos => {
18373 if sst_infos__.is_some() {
18374 return Err(serde::de::Error::duplicate_field("sstInfos"));
18375 }
18376 sst_infos__ = Some(map_.next_value()?);
18377 }
18378 GeneratedField::SstIdToWorkerId => {
18379 if sst_id_to_worker_id__.is_some() {
18380 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
18381 }
18382 sst_id_to_worker_id__ = Some(
18383 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
18384 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
18385 );
18386 }
18387 }
18388 }
18389 Ok(ValidationTask {
18390 sst_infos: sst_infos__.unwrap_or_default(),
18391 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
18392 })
18393 }
18394 }
18395 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
18396 }
18397}
18398impl serde::Serialize for VectorFileInfo {
18399 #[allow(deprecated)]
18400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18401 where
18402 S: serde::Serializer,
18403 {
18404 use serde::ser::SerializeStruct;
18405 let mut len = 0;
18406 if self.object_id != 0 {
18407 len += 1;
18408 }
18409 if self.file_size != 0 {
18410 len += 1;
18411 }
18412 if self.start_vector_id != 0 {
18413 len += 1;
18414 }
18415 if self.vector_count != 0 {
18416 len += 1;
18417 }
18418 if self.meta_offset != 0 {
18419 len += 1;
18420 }
18421 let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
18422 if self.object_id != 0 {
18423 #[allow(clippy::needless_borrow)]
18424 #[allow(clippy::needless_borrows_for_generic_args)]
18425 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
18426 }
18427 if self.file_size != 0 {
18428 #[allow(clippy::needless_borrow)]
18429 #[allow(clippy::needless_borrows_for_generic_args)]
18430 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
18431 }
18432 if self.start_vector_id != 0 {
18433 #[allow(clippy::needless_borrow)]
18434 #[allow(clippy::needless_borrows_for_generic_args)]
18435 struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
18436 }
18437 if self.vector_count != 0 {
18438 struct_ser.serialize_field("vectorCount", &self.vector_count)?;
18439 }
18440 if self.meta_offset != 0 {
18441 #[allow(clippy::needless_borrow)]
18442 #[allow(clippy::needless_borrows_for_generic_args)]
18443 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
18444 }
18445 struct_ser.end()
18446 }
18447}
18448impl<'de> serde::Deserialize<'de> for VectorFileInfo {
18449 #[allow(deprecated)]
18450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18451 where
18452 D: serde::Deserializer<'de>,
18453 {
18454 const FIELDS: &[&str] = &[
18455 "object_id",
18456 "objectId",
18457 "file_size",
18458 "fileSize",
18459 "start_vector_id",
18460 "startVectorId",
18461 "vector_count",
18462 "vectorCount",
18463 "meta_offset",
18464 "metaOffset",
18465 ];
18466
18467 #[allow(clippy::enum_variant_names)]
18468 enum GeneratedField {
18469 ObjectId,
18470 FileSize,
18471 StartVectorId,
18472 VectorCount,
18473 MetaOffset,
18474 }
18475 impl<'de> serde::Deserialize<'de> for GeneratedField {
18476 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18477 where
18478 D: serde::Deserializer<'de>,
18479 {
18480 struct GeneratedVisitor;
18481
18482 impl serde::de::Visitor<'_> for GeneratedVisitor {
18483 type Value = GeneratedField;
18484
18485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18486 write!(formatter, "expected one of: {:?}", &FIELDS)
18487 }
18488
18489 #[allow(unused_variables)]
18490 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18491 where
18492 E: serde::de::Error,
18493 {
18494 match value {
18495 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
18496 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
18497 "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
18498 "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
18499 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
18500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18501 }
18502 }
18503 }
18504 deserializer.deserialize_identifier(GeneratedVisitor)
18505 }
18506 }
18507 struct GeneratedVisitor;
18508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18509 type Value = VectorFileInfo;
18510
18511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18512 formatter.write_str("struct hummock.VectorFileInfo")
18513 }
18514
18515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
18516 where
18517 V: serde::de::MapAccess<'de>,
18518 {
18519 let mut object_id__ = None;
18520 let mut file_size__ = None;
18521 let mut start_vector_id__ = None;
18522 let mut vector_count__ = None;
18523 let mut meta_offset__ = None;
18524 while let Some(k) = map_.next_key()? {
18525 match k {
18526 GeneratedField::ObjectId => {
18527 if object_id__.is_some() {
18528 return Err(serde::de::Error::duplicate_field("objectId"));
18529 }
18530 object_id__ =
18531 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18532 ;
18533 }
18534 GeneratedField::FileSize => {
18535 if file_size__.is_some() {
18536 return Err(serde::de::Error::duplicate_field("fileSize"));
18537 }
18538 file_size__ =
18539 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18540 ;
18541 }
18542 GeneratedField::StartVectorId => {
18543 if start_vector_id__.is_some() {
18544 return Err(serde::de::Error::duplicate_field("startVectorId"));
18545 }
18546 start_vector_id__ =
18547 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18548 ;
18549 }
18550 GeneratedField::VectorCount => {
18551 if vector_count__.is_some() {
18552 return Err(serde::de::Error::duplicate_field("vectorCount"));
18553 }
18554 vector_count__ =
18555 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18556 ;
18557 }
18558 GeneratedField::MetaOffset => {
18559 if meta_offset__.is_some() {
18560 return Err(serde::de::Error::duplicate_field("metaOffset"));
18561 }
18562 meta_offset__ =
18563 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18564 ;
18565 }
18566 }
18567 }
18568 Ok(VectorFileInfo {
18569 object_id: object_id__.unwrap_or_default(),
18570 file_size: file_size__.unwrap_or_default(),
18571 start_vector_id: start_vector_id__.unwrap_or_default(),
18572 vector_count: vector_count__.unwrap_or_default(),
18573 meta_offset: meta_offset__.unwrap_or_default(),
18574 })
18575 }
18576 }
18577 deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
18578 }
18579}
18580impl serde::Serialize for VectorIndex {
18581 #[allow(deprecated)]
18582 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18583 where
18584 S: serde::Serializer,
18585 {
18586 use serde::ser::SerializeStruct;
18587 let mut len = 0;
18588 if self.dimension != 0 {
18589 len += 1;
18590 }
18591 if self.distance_type != 0 {
18592 len += 1;
18593 }
18594 if self.variant.is_some() {
18595 len += 1;
18596 }
18597 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
18598 if self.dimension != 0 {
18599 struct_ser.serialize_field("dimension", &self.dimension)?;
18600 }
18601 if self.distance_type != 0 {
18602 let v = super::common::DistanceType::try_from(self.distance_type)
18603 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
18604 struct_ser.serialize_field("distanceType", &v)?;
18605 }
18606 if let Some(v) = self.variant.as_ref() {
18607 match v {
18608 vector_index::Variant::Flat(v) => {
18609 struct_ser.serialize_field("flat", v)?;
18610 }
18611 vector_index::Variant::HnswFlat(v) => {
18612 struct_ser.serialize_field("hnswFlat", v)?;
18613 }
18614 }
18615 }
18616 struct_ser.end()
18617 }
18618}
18619impl<'de> serde::Deserialize<'de> for VectorIndex {
18620 #[allow(deprecated)]
18621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18622 where
18623 D: serde::Deserializer<'de>,
18624 {
18625 const FIELDS: &[&str] = &[
18626 "dimension",
18627 "distance_type",
18628 "distanceType",
18629 "flat",
18630 "hnsw_flat",
18631 "hnswFlat",
18632 ];
18633
18634 #[allow(clippy::enum_variant_names)]
18635 enum GeneratedField {
18636 Dimension,
18637 DistanceType,
18638 Flat,
18639 HnswFlat,
18640 }
18641 impl<'de> serde::Deserialize<'de> for GeneratedField {
18642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18643 where
18644 D: serde::Deserializer<'de>,
18645 {
18646 struct GeneratedVisitor;
18647
18648 impl serde::de::Visitor<'_> for GeneratedVisitor {
18649 type Value = GeneratedField;
18650
18651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18652 write!(formatter, "expected one of: {:?}", &FIELDS)
18653 }
18654
18655 #[allow(unused_variables)]
18656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18657 where
18658 E: serde::de::Error,
18659 {
18660 match value {
18661 "dimension" => Ok(GeneratedField::Dimension),
18662 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
18663 "flat" => Ok(GeneratedField::Flat),
18664 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
18665 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18666 }
18667 }
18668 }
18669 deserializer.deserialize_identifier(GeneratedVisitor)
18670 }
18671 }
18672 struct GeneratedVisitor;
18673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18674 type Value = VectorIndex;
18675
18676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18677 formatter.write_str("struct hummock.VectorIndex")
18678 }
18679
18680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
18681 where
18682 V: serde::de::MapAccess<'de>,
18683 {
18684 let mut dimension__ = None;
18685 let mut distance_type__ = None;
18686 let mut variant__ = None;
18687 while let Some(k) = map_.next_key()? {
18688 match k {
18689 GeneratedField::Dimension => {
18690 if dimension__.is_some() {
18691 return Err(serde::de::Error::duplicate_field("dimension"));
18692 }
18693 dimension__ =
18694 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18695 ;
18696 }
18697 GeneratedField::DistanceType => {
18698 if distance_type__.is_some() {
18699 return Err(serde::de::Error::duplicate_field("distanceType"));
18700 }
18701 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
18702 }
18703 GeneratedField::Flat => {
18704 if variant__.is_some() {
18705 return Err(serde::de::Error::duplicate_field("flat"));
18706 }
18707 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
18708;
18709 }
18710 GeneratedField::HnswFlat => {
18711 if variant__.is_some() {
18712 return Err(serde::de::Error::duplicate_field("hnswFlat"));
18713 }
18714 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::HnswFlat)
18715;
18716 }
18717 }
18718 }
18719 Ok(VectorIndex {
18720 dimension: dimension__.unwrap_or_default(),
18721 distance_type: distance_type__.unwrap_or_default(),
18722 variant: variant__,
18723 })
18724 }
18725 }
18726 deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
18727 }
18728}
18729impl serde::Serialize for VectorIndexDelta {
18730 #[allow(deprecated)]
18731 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18732 where
18733 S: serde::Serializer,
18734 {
18735 use serde::ser::SerializeStruct;
18736 let mut len = 0;
18737 if self.delta.is_some() {
18738 len += 1;
18739 }
18740 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
18741 if let Some(v) = self.delta.as_ref() {
18742 match v {
18743 vector_index_delta::Delta::Init(v) => {
18744 struct_ser.serialize_field("init", v)?;
18745 }
18746 vector_index_delta::Delta::Adds(v) => {
18747 struct_ser.serialize_field("adds", v)?;
18748 }
18749 }
18750 }
18751 struct_ser.end()
18752 }
18753}
18754impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
18755 #[allow(deprecated)]
18756 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18757 where
18758 D: serde::Deserializer<'de>,
18759 {
18760 const FIELDS: &[&str] = &[
18761 "init",
18762 "adds",
18763 ];
18764
18765 #[allow(clippy::enum_variant_names)]
18766 enum GeneratedField {
18767 Init,
18768 Adds,
18769 }
18770 impl<'de> serde::Deserialize<'de> for GeneratedField {
18771 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18772 where
18773 D: serde::Deserializer<'de>,
18774 {
18775 struct GeneratedVisitor;
18776
18777 impl serde::de::Visitor<'_> for GeneratedVisitor {
18778 type Value = GeneratedField;
18779
18780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18781 write!(formatter, "expected one of: {:?}", &FIELDS)
18782 }
18783
18784 #[allow(unused_variables)]
18785 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18786 where
18787 E: serde::de::Error,
18788 {
18789 match value {
18790 "init" => Ok(GeneratedField::Init),
18791 "adds" => Ok(GeneratedField::Adds),
18792 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18793 }
18794 }
18795 }
18796 deserializer.deserialize_identifier(GeneratedVisitor)
18797 }
18798 }
18799 struct GeneratedVisitor;
18800 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18801 type Value = VectorIndexDelta;
18802
18803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18804 formatter.write_str("struct hummock.VectorIndexDelta")
18805 }
18806
18807 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
18808 where
18809 V: serde::de::MapAccess<'de>,
18810 {
18811 let mut delta__ = None;
18812 while let Some(k) = map_.next_key()? {
18813 match k {
18814 GeneratedField::Init => {
18815 if delta__.is_some() {
18816 return Err(serde::de::Error::duplicate_field("init"));
18817 }
18818 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
18819;
18820 }
18821 GeneratedField::Adds => {
18822 if delta__.is_some() {
18823 return Err(serde::de::Error::duplicate_field("adds"));
18824 }
18825 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
18826;
18827 }
18828 }
18829 }
18830 Ok(VectorIndexDelta {
18831 delta: delta__,
18832 })
18833 }
18834 }
18835 deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
18836 }
18837}
18838impl serde::Serialize for vector_index_delta::VectorIndexAdd {
18839 #[allow(deprecated)]
18840 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18841 where
18842 S: serde::Serializer,
18843 {
18844 use serde::ser::SerializeStruct;
18845 let mut len = 0;
18846 if self.add.is_some() {
18847 len += 1;
18848 }
18849 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
18850 if let Some(v) = self.add.as_ref() {
18851 match v {
18852 vector_index_delta::vector_index_add::Add::Flat(v) => {
18853 struct_ser.serialize_field("flat", v)?;
18854 }
18855 vector_index_delta::vector_index_add::Add::HnswFlat(v) => {
18856 struct_ser.serialize_field("hnswFlat", v)?;
18857 }
18858 }
18859 }
18860 struct_ser.end()
18861 }
18862}
18863impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
18864 #[allow(deprecated)]
18865 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18866 where
18867 D: serde::Deserializer<'de>,
18868 {
18869 const FIELDS: &[&str] = &[
18870 "flat",
18871 "hnsw_flat",
18872 "hnswFlat",
18873 ];
18874
18875 #[allow(clippy::enum_variant_names)]
18876 enum GeneratedField {
18877 Flat,
18878 HnswFlat,
18879 }
18880 impl<'de> serde::Deserialize<'de> for GeneratedField {
18881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18882 where
18883 D: serde::Deserializer<'de>,
18884 {
18885 struct GeneratedVisitor;
18886
18887 impl serde::de::Visitor<'_> for GeneratedVisitor {
18888 type Value = GeneratedField;
18889
18890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18891 write!(formatter, "expected one of: {:?}", &FIELDS)
18892 }
18893
18894 #[allow(unused_variables)]
18895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18896 where
18897 E: serde::de::Error,
18898 {
18899 match value {
18900 "flat" => Ok(GeneratedField::Flat),
18901 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
18902 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18903 }
18904 }
18905 }
18906 deserializer.deserialize_identifier(GeneratedVisitor)
18907 }
18908 }
18909 struct GeneratedVisitor;
18910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18911 type Value = vector_index_delta::VectorIndexAdd;
18912
18913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18914 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
18915 }
18916
18917 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
18918 where
18919 V: serde::de::MapAccess<'de>,
18920 {
18921 let mut add__ = None;
18922 while let Some(k) = map_.next_key()? {
18923 match k {
18924 GeneratedField::Flat => {
18925 if add__.is_some() {
18926 return Err(serde::de::Error::duplicate_field("flat"));
18927 }
18928 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
18929;
18930 }
18931 GeneratedField::HnswFlat => {
18932 if add__.is_some() {
18933 return Err(serde::de::Error::duplicate_field("hnswFlat"));
18934 }
18935 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::HnswFlat)
18936;
18937 }
18938 }
18939 }
18940 Ok(vector_index_delta::VectorIndexAdd {
18941 add: add__,
18942 })
18943 }
18944 }
18945 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
18946 }
18947}
18948impl serde::Serialize for vector_index_delta::VectorIndexAdds {
18949 #[allow(deprecated)]
18950 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18951 where
18952 S: serde::Serializer,
18953 {
18954 use serde::ser::SerializeStruct;
18955 let mut len = 0;
18956 if !self.adds.is_empty() {
18957 len += 1;
18958 }
18959 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
18960 if !self.adds.is_empty() {
18961 struct_ser.serialize_field("adds", &self.adds)?;
18962 }
18963 struct_ser.end()
18964 }
18965}
18966impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
18967 #[allow(deprecated)]
18968 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18969 where
18970 D: serde::Deserializer<'de>,
18971 {
18972 const FIELDS: &[&str] = &[
18973 "adds",
18974 ];
18975
18976 #[allow(clippy::enum_variant_names)]
18977 enum GeneratedField {
18978 Adds,
18979 }
18980 impl<'de> serde::Deserialize<'de> for GeneratedField {
18981 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18982 where
18983 D: serde::Deserializer<'de>,
18984 {
18985 struct GeneratedVisitor;
18986
18987 impl serde::de::Visitor<'_> for GeneratedVisitor {
18988 type Value = GeneratedField;
18989
18990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18991 write!(formatter, "expected one of: {:?}", &FIELDS)
18992 }
18993
18994 #[allow(unused_variables)]
18995 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18996 where
18997 E: serde::de::Error,
18998 {
18999 match value {
19000 "adds" => Ok(GeneratedField::Adds),
19001 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19002 }
19003 }
19004 }
19005 deserializer.deserialize_identifier(GeneratedVisitor)
19006 }
19007 }
19008 struct GeneratedVisitor;
19009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19010 type Value = vector_index_delta::VectorIndexAdds;
19011
19012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19013 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
19014 }
19015
19016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
19017 where
19018 V: serde::de::MapAccess<'de>,
19019 {
19020 let mut adds__ = None;
19021 while let Some(k) = map_.next_key()? {
19022 match k {
19023 GeneratedField::Adds => {
19024 if adds__.is_some() {
19025 return Err(serde::de::Error::duplicate_field("adds"));
19026 }
19027 adds__ = Some(map_.next_value()?);
19028 }
19029 }
19030 }
19031 Ok(vector_index_delta::VectorIndexAdds {
19032 adds: adds__.unwrap_or_default(),
19033 })
19034 }
19035 }
19036 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
19037 }
19038}
19039impl serde::Serialize for vector_index_delta::VectorIndexInit {
19040 #[allow(deprecated)]
19041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19042 where
19043 S: serde::Serializer,
19044 {
19045 use serde::ser::SerializeStruct;
19046 let mut len = 0;
19047 if self.info.is_some() {
19048 len += 1;
19049 }
19050 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
19051 if let Some(v) = self.info.as_ref() {
19052 struct_ser.serialize_field("info", v)?;
19053 }
19054 struct_ser.end()
19055 }
19056}
19057impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
19058 #[allow(deprecated)]
19059 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19060 where
19061 D: serde::Deserializer<'de>,
19062 {
19063 const FIELDS: &[&str] = &[
19064 "info",
19065 ];
19066
19067 #[allow(clippy::enum_variant_names)]
19068 enum GeneratedField {
19069 Info,
19070 }
19071 impl<'de> serde::Deserialize<'de> for GeneratedField {
19072 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19073 where
19074 D: serde::Deserializer<'de>,
19075 {
19076 struct GeneratedVisitor;
19077
19078 impl serde::de::Visitor<'_> for GeneratedVisitor {
19079 type Value = GeneratedField;
19080
19081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19082 write!(formatter, "expected one of: {:?}", &FIELDS)
19083 }
19084
19085 #[allow(unused_variables)]
19086 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19087 where
19088 E: serde::de::Error,
19089 {
19090 match value {
19091 "info" => Ok(GeneratedField::Info),
19092 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19093 }
19094 }
19095 }
19096 deserializer.deserialize_identifier(GeneratedVisitor)
19097 }
19098 }
19099 struct GeneratedVisitor;
19100 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19101 type Value = vector_index_delta::VectorIndexInit;
19102
19103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19104 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
19105 }
19106
19107 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
19108 where
19109 V: serde::de::MapAccess<'de>,
19110 {
19111 let mut info__ = None;
19112 while let Some(k) = map_.next_key()? {
19113 match k {
19114 GeneratedField::Info => {
19115 if info__.is_some() {
19116 return Err(serde::de::Error::duplicate_field("info"));
19117 }
19118 info__ = map_.next_value()?;
19119 }
19120 }
19121 }
19122 Ok(vector_index_delta::VectorIndexInit {
19123 info: info__,
19124 })
19125 }
19126 }
19127 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
19128 }
19129}
19130impl serde::Serialize for VectorIndexObject {
19131 #[allow(deprecated)]
19132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19133 where
19134 S: serde::Serializer,
19135 {
19136 use serde::ser::SerializeStruct;
19137 let mut len = 0;
19138 if self.id != 0 {
19139 len += 1;
19140 }
19141 if self.object_type != 0 {
19142 len += 1;
19143 }
19144 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
19145 if self.id != 0 {
19146 #[allow(clippy::needless_borrow)]
19147 #[allow(clippy::needless_borrows_for_generic_args)]
19148 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
19149 }
19150 if self.object_type != 0 {
19151 let v = VectorIndexObjectType::try_from(self.object_type)
19152 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
19153 struct_ser.serialize_field("objectType", &v)?;
19154 }
19155 struct_ser.end()
19156 }
19157}
19158impl<'de> serde::Deserialize<'de> for VectorIndexObject {
19159 #[allow(deprecated)]
19160 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19161 where
19162 D: serde::Deserializer<'de>,
19163 {
19164 const FIELDS: &[&str] = &[
19165 "id",
19166 "object_type",
19167 "objectType",
19168 ];
19169
19170 #[allow(clippy::enum_variant_names)]
19171 enum GeneratedField {
19172 Id,
19173 ObjectType,
19174 }
19175 impl<'de> serde::Deserialize<'de> for GeneratedField {
19176 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19177 where
19178 D: serde::Deserializer<'de>,
19179 {
19180 struct GeneratedVisitor;
19181
19182 impl serde::de::Visitor<'_> for GeneratedVisitor {
19183 type Value = GeneratedField;
19184
19185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19186 write!(formatter, "expected one of: {:?}", &FIELDS)
19187 }
19188
19189 #[allow(unused_variables)]
19190 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19191 where
19192 E: serde::de::Error,
19193 {
19194 match value {
19195 "id" => Ok(GeneratedField::Id),
19196 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
19197 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19198 }
19199 }
19200 }
19201 deserializer.deserialize_identifier(GeneratedVisitor)
19202 }
19203 }
19204 struct GeneratedVisitor;
19205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19206 type Value = VectorIndexObject;
19207
19208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19209 formatter.write_str("struct hummock.VectorIndexObject")
19210 }
19211
19212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
19213 where
19214 V: serde::de::MapAccess<'de>,
19215 {
19216 let mut id__ = None;
19217 let mut object_type__ = None;
19218 while let Some(k) = map_.next_key()? {
19219 match k {
19220 GeneratedField::Id => {
19221 if id__.is_some() {
19222 return Err(serde::de::Error::duplicate_field("id"));
19223 }
19224 id__ =
19225 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19226 ;
19227 }
19228 GeneratedField::ObjectType => {
19229 if object_type__.is_some() {
19230 return Err(serde::de::Error::duplicate_field("objectType"));
19231 }
19232 object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
19233 }
19234 }
19235 }
19236 Ok(VectorIndexObject {
19237 id: id__.unwrap_or_default(),
19238 object_type: object_type__.unwrap_or_default(),
19239 })
19240 }
19241 }
19242 deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
19243 }
19244}
19245impl serde::Serialize for VectorIndexObjectType {
19246 #[allow(deprecated)]
19247 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19248 where
19249 S: serde::Serializer,
19250 {
19251 let variant = match self {
19252 Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
19253 Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
19254 Self::VectorIndexObjectHnswGraph => "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
19255 };
19256 serializer.serialize_str(variant)
19257 }
19258}
19259impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
19260 #[allow(deprecated)]
19261 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19262 where
19263 D: serde::Deserializer<'de>,
19264 {
19265 const FIELDS: &[&str] = &[
19266 "VECTOR_INDEX_OBJECT_UNSPECIFIED",
19267 "VECTOR_INDEX_OBJECT_VECTOR",
19268 "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
19269 ];
19270
19271 struct GeneratedVisitor;
19272
19273 impl serde::de::Visitor<'_> for GeneratedVisitor {
19274 type Value = VectorIndexObjectType;
19275
19276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19277 write!(formatter, "expected one of: {:?}", &FIELDS)
19278 }
19279
19280 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19281 where
19282 E: serde::de::Error,
19283 {
19284 i32::try_from(v)
19285 .ok()
19286 .and_then(|x| x.try_into().ok())
19287 .ok_or_else(|| {
19288 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19289 })
19290 }
19291
19292 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19293 where
19294 E: serde::de::Error,
19295 {
19296 i32::try_from(v)
19297 .ok()
19298 .and_then(|x| x.try_into().ok())
19299 .ok_or_else(|| {
19300 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19301 })
19302 }
19303
19304 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19305 where
19306 E: serde::de::Error,
19307 {
19308 match value {
19309 "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
19310 "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
19311 "VECTOR_INDEX_OBJECT_HNSW_GRAPH" => Ok(VectorIndexObjectType::VectorIndexObjectHnswGraph),
19312 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19313 }
19314 }
19315 }
19316 deserializer.deserialize_any(GeneratedVisitor)
19317 }
19318}
19319impl serde::Serialize for VersionUpdatePayload {
19320 #[allow(deprecated)]
19321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19322 where
19323 S: serde::Serializer,
19324 {
19325 use serde::ser::SerializeStruct;
19326 let mut len = 0;
19327 if self.payload.is_some() {
19328 len += 1;
19329 }
19330 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
19331 if let Some(v) = self.payload.as_ref() {
19332 match v {
19333 version_update_payload::Payload::VersionDeltas(v) => {
19334 struct_ser.serialize_field("versionDeltas", v)?;
19335 }
19336 version_update_payload::Payload::PinnedVersion(v) => {
19337 struct_ser.serialize_field("pinnedVersion", v)?;
19338 }
19339 }
19340 }
19341 struct_ser.end()
19342 }
19343}
19344impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
19345 #[allow(deprecated)]
19346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19347 where
19348 D: serde::Deserializer<'de>,
19349 {
19350 const FIELDS: &[&str] = &[
19351 "version_deltas",
19352 "versionDeltas",
19353 "pinned_version",
19354 "pinnedVersion",
19355 ];
19356
19357 #[allow(clippy::enum_variant_names)]
19358 enum GeneratedField {
19359 VersionDeltas,
19360 PinnedVersion,
19361 }
19362 impl<'de> serde::Deserialize<'de> for GeneratedField {
19363 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19364 where
19365 D: serde::Deserializer<'de>,
19366 {
19367 struct GeneratedVisitor;
19368
19369 impl serde::de::Visitor<'_> for GeneratedVisitor {
19370 type Value = GeneratedField;
19371
19372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19373 write!(formatter, "expected one of: {:?}", &FIELDS)
19374 }
19375
19376 #[allow(unused_variables)]
19377 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19378 where
19379 E: serde::de::Error,
19380 {
19381 match value {
19382 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
19383 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
19384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19385 }
19386 }
19387 }
19388 deserializer.deserialize_identifier(GeneratedVisitor)
19389 }
19390 }
19391 struct GeneratedVisitor;
19392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19393 type Value = VersionUpdatePayload;
19394
19395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19396 formatter.write_str("struct hummock.VersionUpdatePayload")
19397 }
19398
19399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
19400 where
19401 V: serde::de::MapAccess<'de>,
19402 {
19403 let mut payload__ = None;
19404 while let Some(k) = map_.next_key()? {
19405 match k {
19406 GeneratedField::VersionDeltas => {
19407 if payload__.is_some() {
19408 return Err(serde::de::Error::duplicate_field("versionDeltas"));
19409 }
19410 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
19411;
19412 }
19413 GeneratedField::PinnedVersion => {
19414 if payload__.is_some() {
19415 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
19416 }
19417 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
19418;
19419 }
19420 }
19421 }
19422 Ok(VersionUpdatePayload {
19423 payload: payload__,
19424 })
19425 }
19426 }
19427 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
19428 }
19429}
19430impl serde::Serialize for VnodeStatistics {
19431 #[allow(deprecated)]
19432 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19433 where
19434 S: serde::Serializer,
19435 {
19436 use serde::ser::SerializeStruct;
19437 let mut len = 0;
19438 if !self.vnode_user_key_ranges.is_empty() {
19439 len += 1;
19440 }
19441 let mut struct_ser = serializer.serialize_struct("hummock.VnodeStatistics", len)?;
19442 if !self.vnode_user_key_ranges.is_empty() {
19443 struct_ser.serialize_field("vnodeUserKeyRanges", &self.vnode_user_key_ranges)?;
19444 }
19445 struct_ser.end()
19446 }
19447}
19448impl<'de> serde::Deserialize<'de> for VnodeStatistics {
19449 #[allow(deprecated)]
19450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19451 where
19452 D: serde::Deserializer<'de>,
19453 {
19454 const FIELDS: &[&str] = &[
19455 "vnode_user_key_ranges",
19456 "vnodeUserKeyRanges",
19457 ];
19458
19459 #[allow(clippy::enum_variant_names)]
19460 enum GeneratedField {
19461 VnodeUserKeyRanges,
19462 }
19463 impl<'de> serde::Deserialize<'de> for GeneratedField {
19464 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19465 where
19466 D: serde::Deserializer<'de>,
19467 {
19468 struct GeneratedVisitor;
19469
19470 impl serde::de::Visitor<'_> for GeneratedVisitor {
19471 type Value = GeneratedField;
19472
19473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19474 write!(formatter, "expected one of: {:?}", &FIELDS)
19475 }
19476
19477 #[allow(unused_variables)]
19478 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19479 where
19480 E: serde::de::Error,
19481 {
19482 match value {
19483 "vnodeUserKeyRanges" | "vnode_user_key_ranges" => Ok(GeneratedField::VnodeUserKeyRanges),
19484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19485 }
19486 }
19487 }
19488 deserializer.deserialize_identifier(GeneratedVisitor)
19489 }
19490 }
19491 struct GeneratedVisitor;
19492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19493 type Value = VnodeStatistics;
19494
19495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19496 formatter.write_str("struct hummock.VnodeStatistics")
19497 }
19498
19499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeStatistics, V::Error>
19500 where
19501 V: serde::de::MapAccess<'de>,
19502 {
19503 let mut vnode_user_key_ranges__ = None;
19504 while let Some(k) = map_.next_key()? {
19505 match k {
19506 GeneratedField::VnodeUserKeyRanges => {
19507 if vnode_user_key_ranges__.is_some() {
19508 return Err(serde::de::Error::duplicate_field("vnodeUserKeyRanges"));
19509 }
19510 vnode_user_key_ranges__ = Some(
19511 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19512 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19513 );
19514 }
19515 }
19516 }
19517 Ok(VnodeStatistics {
19518 vnode_user_key_ranges: vnode_user_key_ranges__.unwrap_or_default(),
19519 })
19520 }
19521 }
19522 deserializer.deserialize_struct("hummock.VnodeStatistics", FIELDS, GeneratedVisitor)
19523 }
19524}
19525impl serde::Serialize for VnodeUserKeyRange {
19526 #[allow(deprecated)]
19527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19528 where
19529 S: serde::Serializer,
19530 {
19531 use serde::ser::SerializeStruct;
19532 let mut len = 0;
19533 if !self.min_key.is_empty() {
19534 len += 1;
19535 }
19536 if !self.max_key.is_empty() {
19537 len += 1;
19538 }
19539 let mut struct_ser = serializer.serialize_struct("hummock.VnodeUserKeyRange", len)?;
19540 if !self.min_key.is_empty() {
19541 #[allow(clippy::needless_borrow)]
19542 #[allow(clippy::needless_borrows_for_generic_args)]
19543 struct_ser.serialize_field("minKey", pbjson::private::base64::encode(&self.min_key).as_str())?;
19544 }
19545 if !self.max_key.is_empty() {
19546 #[allow(clippy::needless_borrow)]
19547 #[allow(clippy::needless_borrows_for_generic_args)]
19548 struct_ser.serialize_field("maxKey", pbjson::private::base64::encode(&self.max_key).as_str())?;
19549 }
19550 struct_ser.end()
19551 }
19552}
19553impl<'de> serde::Deserialize<'de> for VnodeUserKeyRange {
19554 #[allow(deprecated)]
19555 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19556 where
19557 D: serde::Deserializer<'de>,
19558 {
19559 const FIELDS: &[&str] = &[
19560 "min_key",
19561 "minKey",
19562 "max_key",
19563 "maxKey",
19564 ];
19565
19566 #[allow(clippy::enum_variant_names)]
19567 enum GeneratedField {
19568 MinKey,
19569 MaxKey,
19570 }
19571 impl<'de> serde::Deserialize<'de> for GeneratedField {
19572 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19573 where
19574 D: serde::Deserializer<'de>,
19575 {
19576 struct GeneratedVisitor;
19577
19578 impl serde::de::Visitor<'_> for GeneratedVisitor {
19579 type Value = GeneratedField;
19580
19581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19582 write!(formatter, "expected one of: {:?}", &FIELDS)
19583 }
19584
19585 #[allow(unused_variables)]
19586 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19587 where
19588 E: serde::de::Error,
19589 {
19590 match value {
19591 "minKey" | "min_key" => Ok(GeneratedField::MinKey),
19592 "maxKey" | "max_key" => Ok(GeneratedField::MaxKey),
19593 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19594 }
19595 }
19596 }
19597 deserializer.deserialize_identifier(GeneratedVisitor)
19598 }
19599 }
19600 struct GeneratedVisitor;
19601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19602 type Value = VnodeUserKeyRange;
19603
19604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19605 formatter.write_str("struct hummock.VnodeUserKeyRange")
19606 }
19607
19608 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeUserKeyRange, V::Error>
19609 where
19610 V: serde::de::MapAccess<'de>,
19611 {
19612 let mut min_key__ = None;
19613 let mut max_key__ = None;
19614 while let Some(k) = map_.next_key()? {
19615 match k {
19616 GeneratedField::MinKey => {
19617 if min_key__.is_some() {
19618 return Err(serde::de::Error::duplicate_field("minKey"));
19619 }
19620 min_key__ =
19621 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
19622 ;
19623 }
19624 GeneratedField::MaxKey => {
19625 if max_key__.is_some() {
19626 return Err(serde::de::Error::duplicate_field("maxKey"));
19627 }
19628 max_key__ =
19629 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
19630 ;
19631 }
19632 }
19633 }
19634 Ok(VnodeUserKeyRange {
19635 min_key: min_key__.unwrap_or_default(),
19636 max_key: max_key__.unwrap_or_default(),
19637 })
19638 }
19639 }
19640 deserializer.deserialize_struct("hummock.VnodeUserKeyRange", FIELDS, GeneratedVisitor)
19641 }
19642}
19643impl serde::Serialize for VnodeWatermark {
19644 #[allow(deprecated)]
19645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19646 where
19647 S: serde::Serializer,
19648 {
19649 use serde::ser::SerializeStruct;
19650 let mut len = 0;
19651 if !self.watermark.is_empty() {
19652 len += 1;
19653 }
19654 if self.vnode_bitmap.is_some() {
19655 len += 1;
19656 }
19657 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
19658 if !self.watermark.is_empty() {
19659 #[allow(clippy::needless_borrow)]
19660 #[allow(clippy::needless_borrows_for_generic_args)]
19661 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
19662 }
19663 if let Some(v) = self.vnode_bitmap.as_ref() {
19664 struct_ser.serialize_field("vnodeBitmap", v)?;
19665 }
19666 struct_ser.end()
19667 }
19668}
19669impl<'de> serde::Deserialize<'de> for VnodeWatermark {
19670 #[allow(deprecated)]
19671 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19672 where
19673 D: serde::Deserializer<'de>,
19674 {
19675 const FIELDS: &[&str] = &[
19676 "watermark",
19677 "vnode_bitmap",
19678 "vnodeBitmap",
19679 ];
19680
19681 #[allow(clippy::enum_variant_names)]
19682 enum GeneratedField {
19683 Watermark,
19684 VnodeBitmap,
19685 }
19686 impl<'de> serde::Deserialize<'de> for GeneratedField {
19687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19688 where
19689 D: serde::Deserializer<'de>,
19690 {
19691 struct GeneratedVisitor;
19692
19693 impl serde::de::Visitor<'_> for GeneratedVisitor {
19694 type Value = GeneratedField;
19695
19696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19697 write!(formatter, "expected one of: {:?}", &FIELDS)
19698 }
19699
19700 #[allow(unused_variables)]
19701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19702 where
19703 E: serde::de::Error,
19704 {
19705 match value {
19706 "watermark" => Ok(GeneratedField::Watermark),
19707 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
19708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19709 }
19710 }
19711 }
19712 deserializer.deserialize_identifier(GeneratedVisitor)
19713 }
19714 }
19715 struct GeneratedVisitor;
19716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19717 type Value = VnodeWatermark;
19718
19719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19720 formatter.write_str("struct hummock.VnodeWatermark")
19721 }
19722
19723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
19724 where
19725 V: serde::de::MapAccess<'de>,
19726 {
19727 let mut watermark__ = None;
19728 let mut vnode_bitmap__ = None;
19729 while let Some(k) = map_.next_key()? {
19730 match k {
19731 GeneratedField::Watermark => {
19732 if watermark__.is_some() {
19733 return Err(serde::de::Error::duplicate_field("watermark"));
19734 }
19735 watermark__ =
19736 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
19737 ;
19738 }
19739 GeneratedField::VnodeBitmap => {
19740 if vnode_bitmap__.is_some() {
19741 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
19742 }
19743 vnode_bitmap__ = map_.next_value()?;
19744 }
19745 }
19746 }
19747 Ok(VnodeWatermark {
19748 watermark: watermark__.unwrap_or_default(),
19749 vnode_bitmap: vnode_bitmap__,
19750 })
19751 }
19752 }
19753 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
19754 }
19755}
19756impl serde::Serialize for WatermarkSerdeType {
19757 #[allow(deprecated)]
19758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19759 where
19760 S: serde::Serializer,
19761 {
19762 let variant = match self {
19763 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
19764 Self::PkPrefix => "PK_PREFIX",
19765 Self::NonPkPrefix => "NON_PK_PREFIX",
19766 Self::Value => "VALUE",
19767 };
19768 serializer.serialize_str(variant)
19769 }
19770}
19771impl<'de> serde::Deserialize<'de> for WatermarkSerdeType {
19772 #[allow(deprecated)]
19773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19774 where
19775 D: serde::Deserializer<'de>,
19776 {
19777 const FIELDS: &[&str] = &[
19778 "TYPE_UNSPECIFIED",
19779 "PK_PREFIX",
19780 "NON_PK_PREFIX",
19781 "VALUE",
19782 ];
19783
19784 struct GeneratedVisitor;
19785
19786 impl serde::de::Visitor<'_> for GeneratedVisitor {
19787 type Value = WatermarkSerdeType;
19788
19789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19790 write!(formatter, "expected one of: {:?}", &FIELDS)
19791 }
19792
19793 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19794 where
19795 E: serde::de::Error,
19796 {
19797 i32::try_from(v)
19798 .ok()
19799 .and_then(|x| x.try_into().ok())
19800 .ok_or_else(|| {
19801 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19802 })
19803 }
19804
19805 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19806 where
19807 E: serde::de::Error,
19808 {
19809 i32::try_from(v)
19810 .ok()
19811 .and_then(|x| x.try_into().ok())
19812 .ok_or_else(|| {
19813 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19814 })
19815 }
19816
19817 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19818 where
19819 E: serde::de::Error,
19820 {
19821 match value {
19822 "TYPE_UNSPECIFIED" => Ok(WatermarkSerdeType::TypeUnspecified),
19823 "PK_PREFIX" => Ok(WatermarkSerdeType::PkPrefix),
19824 "NON_PK_PREFIX" => Ok(WatermarkSerdeType::NonPkPrefix),
19825 "VALUE" => Ok(WatermarkSerdeType::Value),
19826 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19827 }
19828 }
19829 }
19830 deserializer.deserialize_any(GeneratedVisitor)
19831 }
19832}
19833impl serde::Serialize for WriteLimits {
19834 #[allow(deprecated)]
19835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19836 where
19837 S: serde::Serializer,
19838 {
19839 use serde::ser::SerializeStruct;
19840 let mut len = 0;
19841 if !self.write_limits.is_empty() {
19842 len += 1;
19843 }
19844 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
19845 if !self.write_limits.is_empty() {
19846 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
19847 }
19848 struct_ser.end()
19849 }
19850}
19851impl<'de> serde::Deserialize<'de> for WriteLimits {
19852 #[allow(deprecated)]
19853 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19854 where
19855 D: serde::Deserializer<'de>,
19856 {
19857 const FIELDS: &[&str] = &[
19858 "write_limits",
19859 "writeLimits",
19860 ];
19861
19862 #[allow(clippy::enum_variant_names)]
19863 enum GeneratedField {
19864 WriteLimits,
19865 }
19866 impl<'de> serde::Deserialize<'de> for GeneratedField {
19867 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19868 where
19869 D: serde::Deserializer<'de>,
19870 {
19871 struct GeneratedVisitor;
19872
19873 impl serde::de::Visitor<'_> for GeneratedVisitor {
19874 type Value = GeneratedField;
19875
19876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19877 write!(formatter, "expected one of: {:?}", &FIELDS)
19878 }
19879
19880 #[allow(unused_variables)]
19881 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19882 where
19883 E: serde::de::Error,
19884 {
19885 match value {
19886 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
19887 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19888 }
19889 }
19890 }
19891 deserializer.deserialize_identifier(GeneratedVisitor)
19892 }
19893 }
19894 struct GeneratedVisitor;
19895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19896 type Value = WriteLimits;
19897
19898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19899 formatter.write_str("struct hummock.WriteLimits")
19900 }
19901
19902 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
19903 where
19904 V: serde::de::MapAccess<'de>,
19905 {
19906 let mut write_limits__ = None;
19907 while let Some(k) = map_.next_key()? {
19908 match k {
19909 GeneratedField::WriteLimits => {
19910 if write_limits__.is_some() {
19911 return Err(serde::de::Error::duplicate_field("writeLimits"));
19912 }
19913 write_limits__ = Some(
19914 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
19915 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19916 );
19917 }
19918 }
19919 }
19920 Ok(WriteLimits {
19921 write_limits: write_limits__.unwrap_or_default(),
19922 })
19923 }
19924 }
19925 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
19926 }
19927}
19928impl serde::Serialize for write_limits::WriteLimit {
19929 #[allow(deprecated)]
19930 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19931 where
19932 S: serde::Serializer,
19933 {
19934 use serde::ser::SerializeStruct;
19935 let mut len = 0;
19936 if !self.table_ids.is_empty() {
19937 len += 1;
19938 }
19939 if !self.reason.is_empty() {
19940 len += 1;
19941 }
19942 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
19943 if !self.table_ids.is_empty() {
19944 struct_ser.serialize_field("tableIds", &self.table_ids)?;
19945 }
19946 if !self.reason.is_empty() {
19947 struct_ser.serialize_field("reason", &self.reason)?;
19948 }
19949 struct_ser.end()
19950 }
19951}
19952impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
19953 #[allow(deprecated)]
19954 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19955 where
19956 D: serde::Deserializer<'de>,
19957 {
19958 const FIELDS: &[&str] = &[
19959 "table_ids",
19960 "tableIds",
19961 "reason",
19962 ];
19963
19964 #[allow(clippy::enum_variant_names)]
19965 enum GeneratedField {
19966 TableIds,
19967 Reason,
19968 }
19969 impl<'de> serde::Deserialize<'de> for GeneratedField {
19970 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19971 where
19972 D: serde::Deserializer<'de>,
19973 {
19974 struct GeneratedVisitor;
19975
19976 impl serde::de::Visitor<'_> for GeneratedVisitor {
19977 type Value = GeneratedField;
19978
19979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19980 write!(formatter, "expected one of: {:?}", &FIELDS)
19981 }
19982
19983 #[allow(unused_variables)]
19984 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19985 where
19986 E: serde::de::Error,
19987 {
19988 match value {
19989 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
19990 "reason" => Ok(GeneratedField::Reason),
19991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19992 }
19993 }
19994 }
19995 deserializer.deserialize_identifier(GeneratedVisitor)
19996 }
19997 }
19998 struct GeneratedVisitor;
19999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20000 type Value = write_limits::WriteLimit;
20001
20002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20003 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
20004 }
20005
20006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
20007 where
20008 V: serde::de::MapAccess<'de>,
20009 {
20010 let mut table_ids__ = None;
20011 let mut reason__ = None;
20012 while let Some(k) = map_.next_key()? {
20013 match k {
20014 GeneratedField::TableIds => {
20015 if table_ids__.is_some() {
20016 return Err(serde::de::Error::duplicate_field("tableIds"));
20017 }
20018 table_ids__ =
20019 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20020 .into_iter().map(|x| x.0).collect())
20021 ;
20022 }
20023 GeneratedField::Reason => {
20024 if reason__.is_some() {
20025 return Err(serde::de::Error::duplicate_field("reason"));
20026 }
20027 reason__ = Some(map_.next_value()?);
20028 }
20029 }
20030 }
20031 Ok(write_limits::WriteLimit {
20032 table_ids: table_ids__.unwrap_or_default(),
20033 reason: reason__.unwrap_or_default(),
20034 })
20035 }
20036 }
20037 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
20038 }
20039}