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 let mut struct_ser = serializer.serialize_struct("hummock.CompactTask", len)?;
814 if !self.input_ssts.is_empty() {
815 struct_ser.serialize_field("inputSsts", &self.input_ssts)?;
816 }
817 if !self.splits.is_empty() {
818 struct_ser.serialize_field("splits", &self.splits)?;
819 }
820 if !self.sorted_output_ssts.is_empty() {
821 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
822 }
823 if self.task_id != 0 {
824 #[allow(clippy::needless_borrow)]
825 #[allow(clippy::needless_borrows_for_generic_args)]
826 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
827 }
828 if self.target_level != 0 {
829 struct_ser.serialize_field("targetLevel", &self.target_level)?;
830 }
831 if self.gc_delete_keys {
832 struct_ser.serialize_field("gcDeleteKeys", &self.gc_delete_keys)?;
833 }
834 if self.base_level != 0 {
835 struct_ser.serialize_field("baseLevel", &self.base_level)?;
836 }
837 if self.task_status != 0 {
838 let v = compact_task::TaskStatus::try_from(self.task_status)
839 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
840 struct_ser.serialize_field("taskStatus", &v)?;
841 }
842 if self.compaction_group_id != 0 {
843 #[allow(clippy::needless_borrow)]
844 #[allow(clippy::needless_borrows_for_generic_args)]
845 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
846 }
847 if !self.existing_table_ids.is_empty() {
848 struct_ser.serialize_field("existingTableIds", &self.existing_table_ids)?;
849 }
850 if self.compression_algorithm != 0 {
851 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
852 }
853 if self.target_file_size != 0 {
854 #[allow(clippy::needless_borrow)]
855 #[allow(clippy::needless_borrows_for_generic_args)]
856 struct_ser.serialize_field("targetFileSize", ToString::to_string(&self.target_file_size).as_str())?;
857 }
858 if self.compaction_filter_mask != 0 {
859 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
860 }
861 if !self.table_options.is_empty() {
862 struct_ser.serialize_field("tableOptions", &self.table_options)?;
863 }
864 if self.current_epoch_time != 0 {
865 #[allow(clippy::needless_borrow)]
866 #[allow(clippy::needless_borrows_for_generic_args)]
867 struct_ser.serialize_field("currentEpochTime", ToString::to_string(&self.current_epoch_time).as_str())?;
868 }
869 if self.target_sub_level_id != 0 {
870 #[allow(clippy::needless_borrow)]
871 #[allow(clippy::needless_borrows_for_generic_args)]
872 struct_ser.serialize_field("targetSubLevelId", ToString::to_string(&self.target_sub_level_id).as_str())?;
873 }
874 if self.task_type != 0 {
875 let v = compact_task::TaskType::try_from(self.task_type)
876 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_type)))?;
877 struct_ser.serialize_field("taskType", &v)?;
878 }
879 if self.split_by_state_table {
880 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
881 }
882 if self.split_weight_by_vnode != 0 {
883 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
884 }
885 if !self.table_vnode_partition.is_empty() {
886 struct_ser.serialize_field("tableVnodePartition", &self.table_vnode_partition)?;
887 }
888 if !self.table_watermarks.is_empty() {
889 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
890 }
891 if !self.table_schemas.is_empty() {
892 struct_ser.serialize_field("tableSchemas", &self.table_schemas)?;
893 }
894 if self.max_sub_compaction != 0 {
895 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
896 }
897 if self.compaction_group_version_id != 0 {
898 #[allow(clippy::needless_borrow)]
899 #[allow(clippy::needless_borrows_for_generic_args)]
900 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
901 }
902 if let Some(v) = self.max_kv_count_for_xor16.as_ref() {
903 #[allow(clippy::needless_borrow)]
904 #[allow(clippy::needless_borrows_for_generic_args)]
905 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
906 }
907 if let Some(v) = self.max_vnode_key_range_bytes.as_ref() {
908 #[allow(clippy::needless_borrow)]
909 #[allow(clippy::needless_borrows_for_generic_args)]
910 struct_ser.serialize_field("maxVnodeKeyRangeBytes", ToString::to_string(&v).as_str())?;
911 }
912 struct_ser.end()
913 }
914}
915impl<'de> serde::Deserialize<'de> for CompactTask {
916 #[allow(deprecated)]
917 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
918 where
919 D: serde::Deserializer<'de>,
920 {
921 const FIELDS: &[&str] = &[
922 "input_ssts",
923 "inputSsts",
924 "splits",
925 "sorted_output_ssts",
926 "sortedOutputSsts",
927 "task_id",
928 "taskId",
929 "target_level",
930 "targetLevel",
931 "gc_delete_keys",
932 "gcDeleteKeys",
933 "base_level",
934 "baseLevel",
935 "task_status",
936 "taskStatus",
937 "compaction_group_id",
938 "compactionGroupId",
939 "existing_table_ids",
940 "existingTableIds",
941 "compression_algorithm",
942 "compressionAlgorithm",
943 "target_file_size",
944 "targetFileSize",
945 "compaction_filter_mask",
946 "compactionFilterMask",
947 "table_options",
948 "tableOptions",
949 "current_epoch_time",
950 "currentEpochTime",
951 "target_sub_level_id",
952 "targetSubLevelId",
953 "task_type",
954 "taskType",
955 "split_by_state_table",
956 "splitByStateTable",
957 "split_weight_by_vnode",
958 "splitWeightByVnode",
959 "table_vnode_partition",
960 "tableVnodePartition",
961 "table_watermarks",
962 "tableWatermarks",
963 "table_schemas",
964 "tableSchemas",
965 "max_sub_compaction",
966 "maxSubCompaction",
967 "compaction_group_version_id",
968 "compactionGroupVersionId",
969 "max_kv_count_for_xor16",
970 "maxKvCountForXor16",
971 "max_vnode_key_range_bytes",
972 "maxVnodeKeyRangeBytes",
973 ];
974
975 #[allow(clippy::enum_variant_names)]
976 enum GeneratedField {
977 InputSsts,
978 Splits,
979 SortedOutputSsts,
980 TaskId,
981 TargetLevel,
982 GcDeleteKeys,
983 BaseLevel,
984 TaskStatus,
985 CompactionGroupId,
986 ExistingTableIds,
987 CompressionAlgorithm,
988 TargetFileSize,
989 CompactionFilterMask,
990 TableOptions,
991 CurrentEpochTime,
992 TargetSubLevelId,
993 TaskType,
994 SplitByStateTable,
995 SplitWeightByVnode,
996 TableVnodePartition,
997 TableWatermarks,
998 TableSchemas,
999 MaxSubCompaction,
1000 CompactionGroupVersionId,
1001 MaxKvCountForXor16,
1002 MaxVnodeKeyRangeBytes,
1003 }
1004 impl<'de> serde::Deserialize<'de> for GeneratedField {
1005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1006 where
1007 D: serde::Deserializer<'de>,
1008 {
1009 struct GeneratedVisitor;
1010
1011 impl serde::de::Visitor<'_> for GeneratedVisitor {
1012 type Value = GeneratedField;
1013
1014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1015 write!(formatter, "expected one of: {:?}", &FIELDS)
1016 }
1017
1018 #[allow(unused_variables)]
1019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1020 where
1021 E: serde::de::Error,
1022 {
1023 match value {
1024 "inputSsts" | "input_ssts" => Ok(GeneratedField::InputSsts),
1025 "splits" => Ok(GeneratedField::Splits),
1026 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
1027 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1028 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
1029 "gcDeleteKeys" | "gc_delete_keys" => Ok(GeneratedField::GcDeleteKeys),
1030 "baseLevel" | "base_level" => Ok(GeneratedField::BaseLevel),
1031 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
1032 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1033 "existingTableIds" | "existing_table_ids" => Ok(GeneratedField::ExistingTableIds),
1034 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
1035 "targetFileSize" | "target_file_size" => Ok(GeneratedField::TargetFileSize),
1036 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
1037 "tableOptions" | "table_options" => Ok(GeneratedField::TableOptions),
1038 "currentEpochTime" | "current_epoch_time" => Ok(GeneratedField::CurrentEpochTime),
1039 "targetSubLevelId" | "target_sub_level_id" => Ok(GeneratedField::TargetSubLevelId),
1040 "taskType" | "task_type" => Ok(GeneratedField::TaskType),
1041 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
1042 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
1043 "tableVnodePartition" | "table_vnode_partition" => Ok(GeneratedField::TableVnodePartition),
1044 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
1045 "tableSchemas" | "table_schemas" => Ok(GeneratedField::TableSchemas),
1046 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
1047 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
1048 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
1049 "maxVnodeKeyRangeBytes" | "max_vnode_key_range_bytes" => Ok(GeneratedField::MaxVnodeKeyRangeBytes),
1050 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1051 }
1052 }
1053 }
1054 deserializer.deserialize_identifier(GeneratedVisitor)
1055 }
1056 }
1057 struct GeneratedVisitor;
1058 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1059 type Value = CompactTask;
1060
1061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1062 formatter.write_str("struct hummock.CompactTask")
1063 }
1064
1065 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTask, V::Error>
1066 where
1067 V: serde::de::MapAccess<'de>,
1068 {
1069 let mut input_ssts__ = None;
1070 let mut splits__ = None;
1071 let mut sorted_output_ssts__ = None;
1072 let mut task_id__ = None;
1073 let mut target_level__ = None;
1074 let mut gc_delete_keys__ = None;
1075 let mut base_level__ = None;
1076 let mut task_status__ = None;
1077 let mut compaction_group_id__ = None;
1078 let mut existing_table_ids__ = None;
1079 let mut compression_algorithm__ = None;
1080 let mut target_file_size__ = None;
1081 let mut compaction_filter_mask__ = None;
1082 let mut table_options__ = None;
1083 let mut current_epoch_time__ = None;
1084 let mut target_sub_level_id__ = None;
1085 let mut task_type__ = None;
1086 let mut split_by_state_table__ = None;
1087 let mut split_weight_by_vnode__ = None;
1088 let mut table_vnode_partition__ = None;
1089 let mut table_watermarks__ = None;
1090 let mut table_schemas__ = None;
1091 let mut max_sub_compaction__ = None;
1092 let mut compaction_group_version_id__ = None;
1093 let mut max_kv_count_for_xor16__ = None;
1094 let mut max_vnode_key_range_bytes__ = None;
1095 while let Some(k) = map_.next_key()? {
1096 match k {
1097 GeneratedField::InputSsts => {
1098 if input_ssts__.is_some() {
1099 return Err(serde::de::Error::duplicate_field("inputSsts"));
1100 }
1101 input_ssts__ = Some(map_.next_value()?);
1102 }
1103 GeneratedField::Splits => {
1104 if splits__.is_some() {
1105 return Err(serde::de::Error::duplicate_field("splits"));
1106 }
1107 splits__ = Some(map_.next_value()?);
1108 }
1109 GeneratedField::SortedOutputSsts => {
1110 if sorted_output_ssts__.is_some() {
1111 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
1112 }
1113 sorted_output_ssts__ = Some(map_.next_value()?);
1114 }
1115 GeneratedField::TaskId => {
1116 if task_id__.is_some() {
1117 return Err(serde::de::Error::duplicate_field("taskId"));
1118 }
1119 task_id__ =
1120 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1121 ;
1122 }
1123 GeneratedField::TargetLevel => {
1124 if target_level__.is_some() {
1125 return Err(serde::de::Error::duplicate_field("targetLevel"));
1126 }
1127 target_level__ =
1128 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1129 ;
1130 }
1131 GeneratedField::GcDeleteKeys => {
1132 if gc_delete_keys__.is_some() {
1133 return Err(serde::de::Error::duplicate_field("gcDeleteKeys"));
1134 }
1135 gc_delete_keys__ = Some(map_.next_value()?);
1136 }
1137 GeneratedField::BaseLevel => {
1138 if base_level__.is_some() {
1139 return Err(serde::de::Error::duplicate_field("baseLevel"));
1140 }
1141 base_level__ =
1142 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1143 ;
1144 }
1145 GeneratedField::TaskStatus => {
1146 if task_status__.is_some() {
1147 return Err(serde::de::Error::duplicate_field("taskStatus"));
1148 }
1149 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
1150 }
1151 GeneratedField::CompactionGroupId => {
1152 if compaction_group_id__.is_some() {
1153 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1154 }
1155 compaction_group_id__ =
1156 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1157 ;
1158 }
1159 GeneratedField::ExistingTableIds => {
1160 if existing_table_ids__.is_some() {
1161 return Err(serde::de::Error::duplicate_field("existingTableIds"));
1162 }
1163 existing_table_ids__ =
1164 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1165 .into_iter().map(|x| x.0).collect())
1166 ;
1167 }
1168 GeneratedField::CompressionAlgorithm => {
1169 if compression_algorithm__.is_some() {
1170 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
1171 }
1172 compression_algorithm__ =
1173 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1174 ;
1175 }
1176 GeneratedField::TargetFileSize => {
1177 if target_file_size__.is_some() {
1178 return Err(serde::de::Error::duplicate_field("targetFileSize"));
1179 }
1180 target_file_size__ =
1181 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1182 ;
1183 }
1184 GeneratedField::CompactionFilterMask => {
1185 if compaction_filter_mask__.is_some() {
1186 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
1187 }
1188 compaction_filter_mask__ =
1189 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1190 ;
1191 }
1192 GeneratedField::TableOptions => {
1193 if table_options__.is_some() {
1194 return Err(serde::de::Error::duplicate_field("tableOptions"));
1195 }
1196 table_options__ = Some(
1197 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1198 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1199 );
1200 }
1201 GeneratedField::CurrentEpochTime => {
1202 if current_epoch_time__.is_some() {
1203 return Err(serde::de::Error::duplicate_field("currentEpochTime"));
1204 }
1205 current_epoch_time__ =
1206 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1207 ;
1208 }
1209 GeneratedField::TargetSubLevelId => {
1210 if target_sub_level_id__.is_some() {
1211 return Err(serde::de::Error::duplicate_field("targetSubLevelId"));
1212 }
1213 target_sub_level_id__ =
1214 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1215 ;
1216 }
1217 GeneratedField::TaskType => {
1218 if task_type__.is_some() {
1219 return Err(serde::de::Error::duplicate_field("taskType"));
1220 }
1221 task_type__ = Some(map_.next_value::<compact_task::TaskType>()? as i32);
1222 }
1223 GeneratedField::SplitByStateTable => {
1224 if split_by_state_table__.is_some() {
1225 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
1226 }
1227 split_by_state_table__ = Some(map_.next_value()?);
1228 }
1229 GeneratedField::SplitWeightByVnode => {
1230 if split_weight_by_vnode__.is_some() {
1231 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
1232 }
1233 split_weight_by_vnode__ =
1234 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1235 ;
1236 }
1237 GeneratedField::TableVnodePartition => {
1238 if table_vnode_partition__.is_some() {
1239 return Err(serde::de::Error::duplicate_field("tableVnodePartition"));
1240 }
1241 table_vnode_partition__ = Some(
1242 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
1243 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
1244 );
1245 }
1246 GeneratedField::TableWatermarks => {
1247 if table_watermarks__.is_some() {
1248 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
1249 }
1250 table_watermarks__ = Some(
1251 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1252 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1253 );
1254 }
1255 GeneratedField::TableSchemas => {
1256 if table_schemas__.is_some() {
1257 return Err(serde::de::Error::duplicate_field("tableSchemas"));
1258 }
1259 table_schemas__ = Some(
1260 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1261 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1262 );
1263 }
1264 GeneratedField::MaxSubCompaction => {
1265 if max_sub_compaction__.is_some() {
1266 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
1267 }
1268 max_sub_compaction__ =
1269 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1270 ;
1271 }
1272 GeneratedField::CompactionGroupVersionId => {
1273 if compaction_group_version_id__.is_some() {
1274 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
1275 }
1276 compaction_group_version_id__ =
1277 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1278 ;
1279 }
1280 GeneratedField::MaxKvCountForXor16 => {
1281 if max_kv_count_for_xor16__.is_some() {
1282 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
1283 }
1284 max_kv_count_for_xor16__ =
1285 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1286 ;
1287 }
1288 GeneratedField::MaxVnodeKeyRangeBytes => {
1289 if max_vnode_key_range_bytes__.is_some() {
1290 return Err(serde::de::Error::duplicate_field("maxVnodeKeyRangeBytes"));
1291 }
1292 max_vnode_key_range_bytes__ =
1293 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1294 ;
1295 }
1296 }
1297 }
1298 Ok(CompactTask {
1299 input_ssts: input_ssts__.unwrap_or_default(),
1300 splits: splits__.unwrap_or_default(),
1301 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
1302 task_id: task_id__.unwrap_or_default(),
1303 target_level: target_level__.unwrap_or_default(),
1304 gc_delete_keys: gc_delete_keys__.unwrap_or_default(),
1305 base_level: base_level__.unwrap_or_default(),
1306 task_status: task_status__.unwrap_or_default(),
1307 compaction_group_id: compaction_group_id__.unwrap_or_default(),
1308 existing_table_ids: existing_table_ids__.unwrap_or_default(),
1309 compression_algorithm: compression_algorithm__.unwrap_or_default(),
1310 target_file_size: target_file_size__.unwrap_or_default(),
1311 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
1312 table_options: table_options__.unwrap_or_default(),
1313 current_epoch_time: current_epoch_time__.unwrap_or_default(),
1314 target_sub_level_id: target_sub_level_id__.unwrap_or_default(),
1315 task_type: task_type__.unwrap_or_default(),
1316 split_by_state_table: split_by_state_table__.unwrap_or_default(),
1317 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
1318 table_vnode_partition: table_vnode_partition__.unwrap_or_default(),
1319 table_watermarks: table_watermarks__.unwrap_or_default(),
1320 table_schemas: table_schemas__.unwrap_or_default(),
1321 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
1322 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
1323 max_kv_count_for_xor16: max_kv_count_for_xor16__,
1324 max_vnode_key_range_bytes: max_vnode_key_range_bytes__,
1325 })
1326 }
1327 }
1328 deserializer.deserialize_struct("hummock.CompactTask", FIELDS, GeneratedVisitor)
1329 }
1330}
1331impl serde::Serialize for compact_task::TaskStatus {
1332 #[allow(deprecated)]
1333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1334 where
1335 S: serde::Serializer,
1336 {
1337 let variant = match self {
1338 Self::Unspecified => "UNSPECIFIED",
1339 Self::Pending => "PENDING",
1340 Self::Success => "SUCCESS",
1341 Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
1342 Self::NoAvailMemoryResourceCanceled => "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1343 Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
1344 Self::SendFailCanceled => "SEND_FAIL_CANCELED",
1345 Self::ManualCanceled => "MANUAL_CANCELED",
1346 Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
1347 Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
1348 Self::ExecuteFailed => "EXECUTE_FAILED",
1349 Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
1350 Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
1351 Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
1352 Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
1353 Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
1354 Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
1355 Self::ServerlessTableNotFoundCanceled => "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1356 };
1357 serializer.serialize_str(variant)
1358 }
1359}
1360impl<'de> serde::Deserialize<'de> for compact_task::TaskStatus {
1361 #[allow(deprecated)]
1362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1363 where
1364 D: serde::Deserializer<'de>,
1365 {
1366 const FIELDS: &[&str] = &[
1367 "UNSPECIFIED",
1368 "PENDING",
1369 "SUCCESS",
1370 "HEARTBEAT_CANCELED",
1371 "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1372 "ASSIGN_FAIL_CANCELED",
1373 "SEND_FAIL_CANCELED",
1374 "MANUAL_CANCELED",
1375 "INVALID_GROUP_CANCELED",
1376 "INPUT_OUTDATED_CANCELED",
1377 "EXECUTE_FAILED",
1378 "JOIN_HANDLE_FAILED",
1379 "TRACK_SST_OBJECT_ID_FAILED",
1380 "NO_AVAIL_CPU_RESOURCE_CANCELED",
1381 "HEARTBEAT_PROGRESS_CANCELED",
1382 "RETENTION_TIME_REJECTED",
1383 "SERVERLESS_SEND_FAIL_CANCELED",
1384 "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1385 ];
1386
1387 struct GeneratedVisitor;
1388
1389 impl serde::de::Visitor<'_> for GeneratedVisitor {
1390 type Value = compact_task::TaskStatus;
1391
1392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1393 write!(formatter, "expected one of: {:?}", &FIELDS)
1394 }
1395
1396 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1397 where
1398 E: serde::de::Error,
1399 {
1400 i32::try_from(v)
1401 .ok()
1402 .and_then(|x| x.try_into().ok())
1403 .ok_or_else(|| {
1404 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1405 })
1406 }
1407
1408 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1409 where
1410 E: serde::de::Error,
1411 {
1412 i32::try_from(v)
1413 .ok()
1414 .and_then(|x| x.try_into().ok())
1415 .ok_or_else(|| {
1416 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1417 })
1418 }
1419
1420 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1421 where
1422 E: serde::de::Error,
1423 {
1424 match value {
1425 "UNSPECIFIED" => Ok(compact_task::TaskStatus::Unspecified),
1426 "PENDING" => Ok(compact_task::TaskStatus::Pending),
1427 "SUCCESS" => Ok(compact_task::TaskStatus::Success),
1428 "HEARTBEAT_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatCanceled),
1429 "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailMemoryResourceCanceled),
1430 "ASSIGN_FAIL_CANCELED" => Ok(compact_task::TaskStatus::AssignFailCanceled),
1431 "SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::SendFailCanceled),
1432 "MANUAL_CANCELED" => Ok(compact_task::TaskStatus::ManualCanceled),
1433 "INVALID_GROUP_CANCELED" => Ok(compact_task::TaskStatus::InvalidGroupCanceled),
1434 "INPUT_OUTDATED_CANCELED" => Ok(compact_task::TaskStatus::InputOutdatedCanceled),
1435 "EXECUTE_FAILED" => Ok(compact_task::TaskStatus::ExecuteFailed),
1436 "JOIN_HANDLE_FAILED" => Ok(compact_task::TaskStatus::JoinHandleFailed),
1437 "TRACK_SST_OBJECT_ID_FAILED" => Ok(compact_task::TaskStatus::TrackSstObjectIdFailed),
1438 "NO_AVAIL_CPU_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailCpuResourceCanceled),
1439 "HEARTBEAT_PROGRESS_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatProgressCanceled),
1440 "RETENTION_TIME_REJECTED" => Ok(compact_task::TaskStatus::RetentionTimeRejected),
1441 "SERVERLESS_SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::ServerlessSendFailCanceled),
1442 "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => Ok(compact_task::TaskStatus::ServerlessTableNotFoundCanceled),
1443 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1444 }
1445 }
1446 }
1447 deserializer.deserialize_any(GeneratedVisitor)
1448 }
1449}
1450impl serde::Serialize for compact_task::TaskType {
1451 #[allow(deprecated)]
1452 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1453 where
1454 S: serde::Serializer,
1455 {
1456 let variant = match self {
1457 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1458 Self::Dynamic => "DYNAMIC",
1459 Self::SpaceReclaim => "SPACE_RECLAIM",
1460 Self::Manual => "MANUAL",
1461 Self::SharedBuffer => "SHARED_BUFFER",
1462 Self::Ttl => "TTL",
1463 Self::Tombstone => "TOMBSTONE",
1464 Self::Emergency => "EMERGENCY",
1465 Self::VnodeWatermark => "VNODE_WATERMARK",
1466 };
1467 serializer.serialize_str(variant)
1468 }
1469}
1470impl<'de> serde::Deserialize<'de> for compact_task::TaskType {
1471 #[allow(deprecated)]
1472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1473 where
1474 D: serde::Deserializer<'de>,
1475 {
1476 const FIELDS: &[&str] = &[
1477 "TYPE_UNSPECIFIED",
1478 "DYNAMIC",
1479 "SPACE_RECLAIM",
1480 "MANUAL",
1481 "SHARED_BUFFER",
1482 "TTL",
1483 "TOMBSTONE",
1484 "EMERGENCY",
1485 "VNODE_WATERMARK",
1486 ];
1487
1488 struct GeneratedVisitor;
1489
1490 impl serde::de::Visitor<'_> for GeneratedVisitor {
1491 type Value = compact_task::TaskType;
1492
1493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1494 write!(formatter, "expected one of: {:?}", &FIELDS)
1495 }
1496
1497 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1498 where
1499 E: serde::de::Error,
1500 {
1501 i32::try_from(v)
1502 .ok()
1503 .and_then(|x| x.try_into().ok())
1504 .ok_or_else(|| {
1505 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1506 })
1507 }
1508
1509 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1510 where
1511 E: serde::de::Error,
1512 {
1513 i32::try_from(v)
1514 .ok()
1515 .and_then(|x| x.try_into().ok())
1516 .ok_or_else(|| {
1517 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1518 })
1519 }
1520
1521 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1522 where
1523 E: serde::de::Error,
1524 {
1525 match value {
1526 "TYPE_UNSPECIFIED" => Ok(compact_task::TaskType::TypeUnspecified),
1527 "DYNAMIC" => Ok(compact_task::TaskType::Dynamic),
1528 "SPACE_RECLAIM" => Ok(compact_task::TaskType::SpaceReclaim),
1529 "MANUAL" => Ok(compact_task::TaskType::Manual),
1530 "SHARED_BUFFER" => Ok(compact_task::TaskType::SharedBuffer),
1531 "TTL" => Ok(compact_task::TaskType::Ttl),
1532 "TOMBSTONE" => Ok(compact_task::TaskType::Tombstone),
1533 "EMERGENCY" => Ok(compact_task::TaskType::Emergency),
1534 "VNODE_WATERMARK" => Ok(compact_task::TaskType::VnodeWatermark),
1535 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1536 }
1537 }
1538 }
1539 deserializer.deserialize_any(GeneratedVisitor)
1540 }
1541}
1542impl serde::Serialize for CompactTaskAssignment {
1543 #[allow(deprecated)]
1544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1545 where
1546 S: serde::Serializer,
1547 {
1548 use serde::ser::SerializeStruct;
1549 let mut len = 0;
1550 if self.compact_task.is_some() {
1551 len += 1;
1552 }
1553 if self.context_id != 0 {
1554 len += 1;
1555 }
1556 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskAssignment", len)?;
1557 if let Some(v) = self.compact_task.as_ref() {
1558 struct_ser.serialize_field("compactTask", v)?;
1559 }
1560 if self.context_id != 0 {
1561 struct_ser.serialize_field("contextId", &self.context_id)?;
1562 }
1563 struct_ser.end()
1564 }
1565}
1566impl<'de> serde::Deserialize<'de> for CompactTaskAssignment {
1567 #[allow(deprecated)]
1568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1569 where
1570 D: serde::Deserializer<'de>,
1571 {
1572 const FIELDS: &[&str] = &[
1573 "compact_task",
1574 "compactTask",
1575 "context_id",
1576 "contextId",
1577 ];
1578
1579 #[allow(clippy::enum_variant_names)]
1580 enum GeneratedField {
1581 CompactTask,
1582 ContextId,
1583 }
1584 impl<'de> serde::Deserialize<'de> for GeneratedField {
1585 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1586 where
1587 D: serde::Deserializer<'de>,
1588 {
1589 struct GeneratedVisitor;
1590
1591 impl serde::de::Visitor<'_> for GeneratedVisitor {
1592 type Value = GeneratedField;
1593
1594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1595 write!(formatter, "expected one of: {:?}", &FIELDS)
1596 }
1597
1598 #[allow(unused_variables)]
1599 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1600 where
1601 E: serde::de::Error,
1602 {
1603 match value {
1604 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
1605 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
1606 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1607 }
1608 }
1609 }
1610 deserializer.deserialize_identifier(GeneratedVisitor)
1611 }
1612 }
1613 struct GeneratedVisitor;
1614 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1615 type Value = CompactTaskAssignment;
1616
1617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1618 formatter.write_str("struct hummock.CompactTaskAssignment")
1619 }
1620
1621 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskAssignment, V::Error>
1622 where
1623 V: serde::de::MapAccess<'de>,
1624 {
1625 let mut compact_task__ = None;
1626 let mut context_id__ = None;
1627 while let Some(k) = map_.next_key()? {
1628 match k {
1629 GeneratedField::CompactTask => {
1630 if compact_task__.is_some() {
1631 return Err(serde::de::Error::duplicate_field("compactTask"));
1632 }
1633 compact_task__ = map_.next_value()?;
1634 }
1635 GeneratedField::ContextId => {
1636 if context_id__.is_some() {
1637 return Err(serde::de::Error::duplicate_field("contextId"));
1638 }
1639 context_id__ =
1640 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1641 ;
1642 }
1643 }
1644 }
1645 Ok(CompactTaskAssignment {
1646 compact_task: compact_task__,
1647 context_id: context_id__.unwrap_or_default(),
1648 })
1649 }
1650 }
1651 deserializer.deserialize_struct("hummock.CompactTaskAssignment", FIELDS, GeneratedVisitor)
1652 }
1653}
1654impl serde::Serialize for CompactTaskProgress {
1655 #[allow(deprecated)]
1656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1657 where
1658 S: serde::Serializer,
1659 {
1660 use serde::ser::SerializeStruct;
1661 let mut len = 0;
1662 if self.task_id != 0 {
1663 len += 1;
1664 }
1665 if self.num_ssts_sealed != 0 {
1666 len += 1;
1667 }
1668 if self.num_ssts_uploaded != 0 {
1669 len += 1;
1670 }
1671 if self.num_progress_key != 0 {
1672 len += 1;
1673 }
1674 if self.num_pending_read_io != 0 {
1675 len += 1;
1676 }
1677 if self.num_pending_write_io != 0 {
1678 len += 1;
1679 }
1680 if self.compaction_group_id.is_some() {
1681 len += 1;
1682 }
1683 let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskProgress", len)?;
1684 if self.task_id != 0 {
1685 #[allow(clippy::needless_borrow)]
1686 #[allow(clippy::needless_borrows_for_generic_args)]
1687 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
1688 }
1689 if self.num_ssts_sealed != 0 {
1690 struct_ser.serialize_field("numSstsSealed", &self.num_ssts_sealed)?;
1691 }
1692 if self.num_ssts_uploaded != 0 {
1693 struct_ser.serialize_field("numSstsUploaded", &self.num_ssts_uploaded)?;
1694 }
1695 if self.num_progress_key != 0 {
1696 #[allow(clippy::needless_borrow)]
1697 #[allow(clippy::needless_borrows_for_generic_args)]
1698 struct_ser.serialize_field("numProgressKey", ToString::to_string(&self.num_progress_key).as_str())?;
1699 }
1700 if self.num_pending_read_io != 0 {
1701 #[allow(clippy::needless_borrow)]
1702 #[allow(clippy::needless_borrows_for_generic_args)]
1703 struct_ser.serialize_field("numPendingReadIo", ToString::to_string(&self.num_pending_read_io).as_str())?;
1704 }
1705 if self.num_pending_write_io != 0 {
1706 #[allow(clippy::needless_borrow)]
1707 #[allow(clippy::needless_borrows_for_generic_args)]
1708 struct_ser.serialize_field("numPendingWriteIo", ToString::to_string(&self.num_pending_write_io).as_str())?;
1709 }
1710 if let Some(v) = self.compaction_group_id.as_ref() {
1711 #[allow(clippy::needless_borrow)]
1712 #[allow(clippy::needless_borrows_for_generic_args)]
1713 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&v).as_str())?;
1714 }
1715 struct_ser.end()
1716 }
1717}
1718impl<'de> serde::Deserialize<'de> for CompactTaskProgress {
1719 #[allow(deprecated)]
1720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1721 where
1722 D: serde::Deserializer<'de>,
1723 {
1724 const FIELDS: &[&str] = &[
1725 "task_id",
1726 "taskId",
1727 "num_ssts_sealed",
1728 "numSstsSealed",
1729 "num_ssts_uploaded",
1730 "numSstsUploaded",
1731 "num_progress_key",
1732 "numProgressKey",
1733 "num_pending_read_io",
1734 "numPendingReadIo",
1735 "num_pending_write_io",
1736 "numPendingWriteIo",
1737 "compaction_group_id",
1738 "compactionGroupId",
1739 ];
1740
1741 #[allow(clippy::enum_variant_names)]
1742 enum GeneratedField {
1743 TaskId,
1744 NumSstsSealed,
1745 NumSstsUploaded,
1746 NumProgressKey,
1747 NumPendingReadIo,
1748 NumPendingWriteIo,
1749 CompactionGroupId,
1750 }
1751 impl<'de> serde::Deserialize<'de> for GeneratedField {
1752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1753 where
1754 D: serde::Deserializer<'de>,
1755 {
1756 struct GeneratedVisitor;
1757
1758 impl serde::de::Visitor<'_> for GeneratedVisitor {
1759 type Value = GeneratedField;
1760
1761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1762 write!(formatter, "expected one of: {:?}", &FIELDS)
1763 }
1764
1765 #[allow(unused_variables)]
1766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1767 where
1768 E: serde::de::Error,
1769 {
1770 match value {
1771 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1772 "numSstsSealed" | "num_ssts_sealed" => Ok(GeneratedField::NumSstsSealed),
1773 "numSstsUploaded" | "num_ssts_uploaded" => Ok(GeneratedField::NumSstsUploaded),
1774 "numProgressKey" | "num_progress_key" => Ok(GeneratedField::NumProgressKey),
1775 "numPendingReadIo" | "num_pending_read_io" => Ok(GeneratedField::NumPendingReadIo),
1776 "numPendingWriteIo" | "num_pending_write_io" => Ok(GeneratedField::NumPendingWriteIo),
1777 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1779 }
1780 }
1781 }
1782 deserializer.deserialize_identifier(GeneratedVisitor)
1783 }
1784 }
1785 struct GeneratedVisitor;
1786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1787 type Value = CompactTaskProgress;
1788
1789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1790 formatter.write_str("struct hummock.CompactTaskProgress")
1791 }
1792
1793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskProgress, V::Error>
1794 where
1795 V: serde::de::MapAccess<'de>,
1796 {
1797 let mut task_id__ = None;
1798 let mut num_ssts_sealed__ = None;
1799 let mut num_ssts_uploaded__ = None;
1800 let mut num_progress_key__ = None;
1801 let mut num_pending_read_io__ = None;
1802 let mut num_pending_write_io__ = None;
1803 let mut compaction_group_id__ = None;
1804 while let Some(k) = map_.next_key()? {
1805 match k {
1806 GeneratedField::TaskId => {
1807 if task_id__.is_some() {
1808 return Err(serde::de::Error::duplicate_field("taskId"));
1809 }
1810 task_id__ =
1811 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1812 ;
1813 }
1814 GeneratedField::NumSstsSealed => {
1815 if num_ssts_sealed__.is_some() {
1816 return Err(serde::de::Error::duplicate_field("numSstsSealed"));
1817 }
1818 num_ssts_sealed__ =
1819 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1820 ;
1821 }
1822 GeneratedField::NumSstsUploaded => {
1823 if num_ssts_uploaded__.is_some() {
1824 return Err(serde::de::Error::duplicate_field("numSstsUploaded"));
1825 }
1826 num_ssts_uploaded__ =
1827 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1828 ;
1829 }
1830 GeneratedField::NumProgressKey => {
1831 if num_progress_key__.is_some() {
1832 return Err(serde::de::Error::duplicate_field("numProgressKey"));
1833 }
1834 num_progress_key__ =
1835 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1836 ;
1837 }
1838 GeneratedField::NumPendingReadIo => {
1839 if num_pending_read_io__.is_some() {
1840 return Err(serde::de::Error::duplicate_field("numPendingReadIo"));
1841 }
1842 num_pending_read_io__ =
1843 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1844 ;
1845 }
1846 GeneratedField::NumPendingWriteIo => {
1847 if num_pending_write_io__.is_some() {
1848 return Err(serde::de::Error::duplicate_field("numPendingWriteIo"));
1849 }
1850 num_pending_write_io__ =
1851 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1852 ;
1853 }
1854 GeneratedField::CompactionGroupId => {
1855 if compaction_group_id__.is_some() {
1856 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1857 }
1858 compaction_group_id__ =
1859 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1860 ;
1861 }
1862 }
1863 }
1864 Ok(CompactTaskProgress {
1865 task_id: task_id__.unwrap_or_default(),
1866 num_ssts_sealed: num_ssts_sealed__.unwrap_or_default(),
1867 num_ssts_uploaded: num_ssts_uploaded__.unwrap_or_default(),
1868 num_progress_key: num_progress_key__.unwrap_or_default(),
1869 num_pending_read_io: num_pending_read_io__.unwrap_or_default(),
1870 num_pending_write_io: num_pending_write_io__.unwrap_or_default(),
1871 compaction_group_id: compaction_group_id__,
1872 })
1873 }
1874 }
1875 deserializer.deserialize_struct("hummock.CompactTaskProgress", FIELDS, GeneratedVisitor)
1876 }
1877}
1878impl serde::Serialize for CompactionConfig {
1879 #[allow(deprecated)]
1880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1881 where
1882 S: serde::Serializer,
1883 {
1884 use serde::ser::SerializeStruct;
1885 let mut len = 0;
1886 if self.max_bytes_for_level_base != 0 {
1887 len += 1;
1888 }
1889 if self.max_level != 0 {
1890 len += 1;
1891 }
1892 if self.max_bytes_for_level_multiplier != 0 {
1893 len += 1;
1894 }
1895 if self.max_compaction_bytes != 0 {
1896 len += 1;
1897 }
1898 if self.sub_level_max_compaction_bytes != 0 {
1899 len += 1;
1900 }
1901 if self.level0_tier_compact_file_number != 0 {
1902 len += 1;
1903 }
1904 if self.compaction_mode != 0 {
1905 len += 1;
1906 }
1907 if !self.compression_algorithm.is_empty() {
1908 len += 1;
1909 }
1910 if self.target_file_size_base != 0 {
1911 len += 1;
1912 }
1913 if self.compaction_filter_mask != 0 {
1914 len += 1;
1915 }
1916 if self.max_sub_compaction != 0 {
1917 len += 1;
1918 }
1919 if self.max_space_reclaim_bytes != 0 {
1920 len += 1;
1921 }
1922 if self.split_by_state_table {
1923 len += 1;
1924 }
1925 if self.split_weight_by_vnode != 0 {
1926 len += 1;
1927 }
1928 if self.level0_stop_write_threshold_sub_level_number != 0 {
1929 len += 1;
1930 }
1931 if self.level0_max_compact_file_number != 0 {
1932 len += 1;
1933 }
1934 if self.level0_sub_level_compact_level_count != 0 {
1935 len += 1;
1936 }
1937 if self.level0_overlapping_sub_level_compact_level_count != 0 {
1938 len += 1;
1939 }
1940 if self.tombstone_reclaim_ratio != 0 {
1941 len += 1;
1942 }
1943 if self.enable_emergency_picker {
1944 len += 1;
1945 }
1946 if self.max_l0_compact_level_count.is_some() {
1947 len += 1;
1948 }
1949 if self.sst_allowed_trivial_move_min_size.is_some() {
1950 len += 1;
1951 }
1952 if self.disable_auto_group_scheduling.is_some() {
1953 len += 1;
1954 }
1955 if self.max_overlapping_level_size.is_some() {
1956 len += 1;
1957 }
1958 if self.emergency_level0_sst_file_count.is_some() {
1959 len += 1;
1960 }
1961 if self.emergency_level0_sub_level_partition.is_some() {
1962 len += 1;
1963 }
1964 if self.level0_stop_write_threshold_max_sst_count.is_some() {
1965 len += 1;
1966 }
1967 if self.level0_stop_write_threshold_max_size.is_some() {
1968 len += 1;
1969 }
1970 if self.sst_allowed_trivial_move_max_count.is_some() {
1971 len += 1;
1972 }
1973 if self.enable_optimize_l0_interval_selection.is_some() {
1974 len += 1;
1975 }
1976 if self.vnode_aligned_level_size_threshold.is_some() {
1977 len += 1;
1978 }
1979 if self.max_kv_count_for_xor16.is_some() {
1980 len += 1;
1981 }
1982 if self.max_vnode_key_range_bytes.is_some() {
1983 len += 1;
1984 }
1985 let mut struct_ser = serializer.serialize_struct("hummock.CompactionConfig", len)?;
1986 if self.max_bytes_for_level_base != 0 {
1987 #[allow(clippy::needless_borrow)]
1988 #[allow(clippy::needless_borrows_for_generic_args)]
1989 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&self.max_bytes_for_level_base).as_str())?;
1990 }
1991 if self.max_level != 0 {
1992 #[allow(clippy::needless_borrow)]
1993 #[allow(clippy::needless_borrows_for_generic_args)]
1994 struct_ser.serialize_field("maxLevel", ToString::to_string(&self.max_level).as_str())?;
1995 }
1996 if self.max_bytes_for_level_multiplier != 0 {
1997 #[allow(clippy::needless_borrow)]
1998 #[allow(clippy::needless_borrows_for_generic_args)]
1999 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&self.max_bytes_for_level_multiplier).as_str())?;
2000 }
2001 if self.max_compaction_bytes != 0 {
2002 #[allow(clippy::needless_borrow)]
2003 #[allow(clippy::needless_borrows_for_generic_args)]
2004 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&self.max_compaction_bytes).as_str())?;
2005 }
2006 if self.sub_level_max_compaction_bytes != 0 {
2007 #[allow(clippy::needless_borrow)]
2008 #[allow(clippy::needless_borrows_for_generic_args)]
2009 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&self.sub_level_max_compaction_bytes).as_str())?;
2010 }
2011 if self.level0_tier_compact_file_number != 0 {
2012 #[allow(clippy::needless_borrow)]
2013 #[allow(clippy::needless_borrows_for_generic_args)]
2014 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&self.level0_tier_compact_file_number).as_str())?;
2015 }
2016 if self.compaction_mode != 0 {
2017 let v = compaction_config::CompactionMode::try_from(self.compaction_mode)
2018 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compaction_mode)))?;
2019 struct_ser.serialize_field("compactionMode", &v)?;
2020 }
2021 if !self.compression_algorithm.is_empty() {
2022 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
2023 }
2024 if self.target_file_size_base != 0 {
2025 #[allow(clippy::needless_borrow)]
2026 #[allow(clippy::needless_borrows_for_generic_args)]
2027 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&self.target_file_size_base).as_str())?;
2028 }
2029 if self.compaction_filter_mask != 0 {
2030 struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
2031 }
2032 if self.max_sub_compaction != 0 {
2033 struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
2034 }
2035 if self.max_space_reclaim_bytes != 0 {
2036 #[allow(clippy::needless_borrow)]
2037 #[allow(clippy::needless_borrows_for_generic_args)]
2038 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&self.max_space_reclaim_bytes).as_str())?;
2039 }
2040 if self.split_by_state_table {
2041 struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
2042 }
2043 if self.split_weight_by_vnode != 0 {
2044 struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
2045 }
2046 if self.level0_stop_write_threshold_sub_level_number != 0 {
2047 #[allow(clippy::needless_borrow)]
2048 #[allow(clippy::needless_borrows_for_generic_args)]
2049 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&self.level0_stop_write_threshold_sub_level_number).as_str())?;
2050 }
2051 if self.level0_max_compact_file_number != 0 {
2052 #[allow(clippy::needless_borrow)]
2053 #[allow(clippy::needless_borrows_for_generic_args)]
2054 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&self.level0_max_compact_file_number).as_str())?;
2055 }
2056 if self.level0_sub_level_compact_level_count != 0 {
2057 struct_ser.serialize_field("level0SubLevelCompactLevelCount", &self.level0_sub_level_compact_level_count)?;
2058 }
2059 if self.level0_overlapping_sub_level_compact_level_count != 0 {
2060 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", &self.level0_overlapping_sub_level_compact_level_count)?;
2061 }
2062 if self.tombstone_reclaim_ratio != 0 {
2063 struct_ser.serialize_field("tombstoneReclaimRatio", &self.tombstone_reclaim_ratio)?;
2064 }
2065 if self.enable_emergency_picker {
2066 struct_ser.serialize_field("enableEmergencyPicker", &self.enable_emergency_picker)?;
2067 }
2068 if let Some(v) = self.max_l0_compact_level_count.as_ref() {
2069 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
2070 }
2071 if let Some(v) = self.sst_allowed_trivial_move_min_size.as_ref() {
2072 #[allow(clippy::needless_borrow)]
2073 #[allow(clippy::needless_borrows_for_generic_args)]
2074 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
2075 }
2076 if let Some(v) = self.disable_auto_group_scheduling.as_ref() {
2077 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
2078 }
2079 if let Some(v) = self.max_overlapping_level_size.as_ref() {
2080 #[allow(clippy::needless_borrow)]
2081 #[allow(clippy::needless_borrows_for_generic_args)]
2082 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
2083 }
2084 if let Some(v) = self.emergency_level0_sst_file_count.as_ref() {
2085 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
2086 }
2087 if let Some(v) = self.emergency_level0_sub_level_partition.as_ref() {
2088 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
2089 }
2090 if let Some(v) = self.level0_stop_write_threshold_max_sst_count.as_ref() {
2091 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
2092 }
2093 if let Some(v) = self.level0_stop_write_threshold_max_size.as_ref() {
2094 #[allow(clippy::needless_borrow)]
2095 #[allow(clippy::needless_borrows_for_generic_args)]
2096 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
2097 }
2098 if let Some(v) = self.sst_allowed_trivial_move_max_count.as_ref() {
2099 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
2100 }
2101 if let Some(v) = self.enable_optimize_l0_interval_selection.as_ref() {
2102 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
2103 }
2104 if let Some(v) = self.vnode_aligned_level_size_threshold.as_ref() {
2105 #[allow(clippy::needless_borrow)]
2106 #[allow(clippy::needless_borrows_for_generic_args)]
2107 struct_ser.serialize_field("vnodeAlignedLevelSizeThreshold", ToString::to_string(&v).as_str())?;
2108 }
2109 if let Some(v) = self.max_kv_count_for_xor16.as_ref() {
2110 #[allow(clippy::needless_borrow)]
2111 #[allow(clippy::needless_borrows_for_generic_args)]
2112 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
2113 }
2114 if let Some(v) = self.max_vnode_key_range_bytes.as_ref() {
2115 #[allow(clippy::needless_borrow)]
2116 #[allow(clippy::needless_borrows_for_generic_args)]
2117 struct_ser.serialize_field("maxVnodeKeyRangeBytes", ToString::to_string(&v).as_str())?;
2118 }
2119 struct_ser.end()
2120 }
2121}
2122impl<'de> serde::Deserialize<'de> for CompactionConfig {
2123 #[allow(deprecated)]
2124 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2125 where
2126 D: serde::Deserializer<'de>,
2127 {
2128 const FIELDS: &[&str] = &[
2129 "max_bytes_for_level_base",
2130 "maxBytesForLevelBase",
2131 "max_level",
2132 "maxLevel",
2133 "max_bytes_for_level_multiplier",
2134 "maxBytesForLevelMultiplier",
2135 "max_compaction_bytes",
2136 "maxCompactionBytes",
2137 "sub_level_max_compaction_bytes",
2138 "subLevelMaxCompactionBytes",
2139 "level0_tier_compact_file_number",
2140 "level0TierCompactFileNumber",
2141 "compaction_mode",
2142 "compactionMode",
2143 "compression_algorithm",
2144 "compressionAlgorithm",
2145 "target_file_size_base",
2146 "targetFileSizeBase",
2147 "compaction_filter_mask",
2148 "compactionFilterMask",
2149 "max_sub_compaction",
2150 "maxSubCompaction",
2151 "max_space_reclaim_bytes",
2152 "maxSpaceReclaimBytes",
2153 "split_by_state_table",
2154 "splitByStateTable",
2155 "split_weight_by_vnode",
2156 "splitWeightByVnode",
2157 "level0_stop_write_threshold_sub_level_number",
2158 "level0StopWriteThresholdSubLevelNumber",
2159 "level0_max_compact_file_number",
2160 "level0MaxCompactFileNumber",
2161 "level0_sub_level_compact_level_count",
2162 "level0SubLevelCompactLevelCount",
2163 "level0_overlapping_sub_level_compact_level_count",
2164 "level0OverlappingSubLevelCompactLevelCount",
2165 "tombstone_reclaim_ratio",
2166 "tombstoneReclaimRatio",
2167 "enable_emergency_picker",
2168 "enableEmergencyPicker",
2169 "max_l0_compact_level_count",
2170 "maxL0CompactLevelCount",
2171 "sst_allowed_trivial_move_min_size",
2172 "sstAllowedTrivialMoveMinSize",
2173 "disable_auto_group_scheduling",
2174 "disableAutoGroupScheduling",
2175 "max_overlapping_level_size",
2176 "maxOverlappingLevelSize",
2177 "emergency_level0_sst_file_count",
2178 "emergencyLevel0SstFileCount",
2179 "emergency_level0_sub_level_partition",
2180 "emergencyLevel0SubLevelPartition",
2181 "level0_stop_write_threshold_max_sst_count",
2182 "level0StopWriteThresholdMaxSstCount",
2183 "level0_stop_write_threshold_max_size",
2184 "level0StopWriteThresholdMaxSize",
2185 "sst_allowed_trivial_move_max_count",
2186 "sstAllowedTrivialMoveMaxCount",
2187 "enable_optimize_l0_interval_selection",
2188 "enableOptimizeL0IntervalSelection",
2189 "vnode_aligned_level_size_threshold",
2190 "vnodeAlignedLevelSizeThreshold",
2191 "max_kv_count_for_xor16",
2192 "maxKvCountForXor16",
2193 "max_vnode_key_range_bytes",
2194 "maxVnodeKeyRangeBytes",
2195 ];
2196
2197 #[allow(clippy::enum_variant_names)]
2198 enum GeneratedField {
2199 MaxBytesForLevelBase,
2200 MaxLevel,
2201 MaxBytesForLevelMultiplier,
2202 MaxCompactionBytes,
2203 SubLevelMaxCompactionBytes,
2204 Level0TierCompactFileNumber,
2205 CompactionMode,
2206 CompressionAlgorithm,
2207 TargetFileSizeBase,
2208 CompactionFilterMask,
2209 MaxSubCompaction,
2210 MaxSpaceReclaimBytes,
2211 SplitByStateTable,
2212 SplitWeightByVnode,
2213 Level0StopWriteThresholdSubLevelNumber,
2214 Level0MaxCompactFileNumber,
2215 Level0SubLevelCompactLevelCount,
2216 Level0OverlappingSubLevelCompactLevelCount,
2217 TombstoneReclaimRatio,
2218 EnableEmergencyPicker,
2219 MaxL0CompactLevelCount,
2220 SstAllowedTrivialMoveMinSize,
2221 DisableAutoGroupScheduling,
2222 MaxOverlappingLevelSize,
2223 EmergencyLevel0SstFileCount,
2224 EmergencyLevel0SubLevelPartition,
2225 Level0StopWriteThresholdMaxSstCount,
2226 Level0StopWriteThresholdMaxSize,
2227 SstAllowedTrivialMoveMaxCount,
2228 EnableOptimizeL0IntervalSelection,
2229 VnodeAlignedLevelSizeThreshold,
2230 MaxKvCountForXor16,
2231 MaxVnodeKeyRangeBytes,
2232 }
2233 impl<'de> serde::Deserialize<'de> for GeneratedField {
2234 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2235 where
2236 D: serde::Deserializer<'de>,
2237 {
2238 struct GeneratedVisitor;
2239
2240 impl serde::de::Visitor<'_> for GeneratedVisitor {
2241 type Value = GeneratedField;
2242
2243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2244 write!(formatter, "expected one of: {:?}", &FIELDS)
2245 }
2246
2247 #[allow(unused_variables)]
2248 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2249 where
2250 E: serde::de::Error,
2251 {
2252 match value {
2253 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
2254 "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2255 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
2256 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
2257 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
2258 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
2259 "compactionMode" | "compaction_mode" => Ok(GeneratedField::CompactionMode),
2260 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
2261 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
2262 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
2263 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
2264 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
2265 "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
2266 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
2267 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
2268 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
2269 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
2270 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
2271 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
2272 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
2273 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
2274 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
2275 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
2276 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
2277 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
2278 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
2279 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
2280 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
2281 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
2282 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
2283 "vnodeAlignedLevelSizeThreshold" | "vnode_aligned_level_size_threshold" => Ok(GeneratedField::VnodeAlignedLevelSizeThreshold),
2284 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
2285 "maxVnodeKeyRangeBytes" | "max_vnode_key_range_bytes" => Ok(GeneratedField::MaxVnodeKeyRangeBytes),
2286 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2287 }
2288 }
2289 }
2290 deserializer.deserialize_identifier(GeneratedVisitor)
2291 }
2292 }
2293 struct GeneratedVisitor;
2294 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2295 type Value = CompactionConfig;
2296
2297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2298 formatter.write_str("struct hummock.CompactionConfig")
2299 }
2300
2301 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionConfig, V::Error>
2302 where
2303 V: serde::de::MapAccess<'de>,
2304 {
2305 let mut max_bytes_for_level_base__ = None;
2306 let mut max_level__ = None;
2307 let mut max_bytes_for_level_multiplier__ = None;
2308 let mut max_compaction_bytes__ = None;
2309 let mut sub_level_max_compaction_bytes__ = None;
2310 let mut level0_tier_compact_file_number__ = None;
2311 let mut compaction_mode__ = None;
2312 let mut compression_algorithm__ = None;
2313 let mut target_file_size_base__ = None;
2314 let mut compaction_filter_mask__ = None;
2315 let mut max_sub_compaction__ = None;
2316 let mut max_space_reclaim_bytes__ = None;
2317 let mut split_by_state_table__ = None;
2318 let mut split_weight_by_vnode__ = None;
2319 let mut level0_stop_write_threshold_sub_level_number__ = None;
2320 let mut level0_max_compact_file_number__ = None;
2321 let mut level0_sub_level_compact_level_count__ = None;
2322 let mut level0_overlapping_sub_level_compact_level_count__ = None;
2323 let mut tombstone_reclaim_ratio__ = None;
2324 let mut enable_emergency_picker__ = None;
2325 let mut max_l0_compact_level_count__ = None;
2326 let mut sst_allowed_trivial_move_min_size__ = None;
2327 let mut disable_auto_group_scheduling__ = None;
2328 let mut max_overlapping_level_size__ = None;
2329 let mut emergency_level0_sst_file_count__ = None;
2330 let mut emergency_level0_sub_level_partition__ = None;
2331 let mut level0_stop_write_threshold_max_sst_count__ = None;
2332 let mut level0_stop_write_threshold_max_size__ = None;
2333 let mut sst_allowed_trivial_move_max_count__ = None;
2334 let mut enable_optimize_l0_interval_selection__ = None;
2335 let mut vnode_aligned_level_size_threshold__ = None;
2336 let mut max_kv_count_for_xor16__ = None;
2337 let mut max_vnode_key_range_bytes__ = None;
2338 while let Some(k) = map_.next_key()? {
2339 match k {
2340 GeneratedField::MaxBytesForLevelBase => {
2341 if max_bytes_for_level_base__.is_some() {
2342 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
2343 }
2344 max_bytes_for_level_base__ =
2345 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2346 ;
2347 }
2348 GeneratedField::MaxLevel => {
2349 if max_level__.is_some() {
2350 return Err(serde::de::Error::duplicate_field("maxLevel"));
2351 }
2352 max_level__ =
2353 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2354 ;
2355 }
2356 GeneratedField::MaxBytesForLevelMultiplier => {
2357 if max_bytes_for_level_multiplier__.is_some() {
2358 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
2359 }
2360 max_bytes_for_level_multiplier__ =
2361 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2362 ;
2363 }
2364 GeneratedField::MaxCompactionBytes => {
2365 if max_compaction_bytes__.is_some() {
2366 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
2367 }
2368 max_compaction_bytes__ =
2369 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2370 ;
2371 }
2372 GeneratedField::SubLevelMaxCompactionBytes => {
2373 if sub_level_max_compaction_bytes__.is_some() {
2374 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
2375 }
2376 sub_level_max_compaction_bytes__ =
2377 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2378 ;
2379 }
2380 GeneratedField::Level0TierCompactFileNumber => {
2381 if level0_tier_compact_file_number__.is_some() {
2382 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
2383 }
2384 level0_tier_compact_file_number__ =
2385 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2386 ;
2387 }
2388 GeneratedField::CompactionMode => {
2389 if compaction_mode__.is_some() {
2390 return Err(serde::de::Error::duplicate_field("compactionMode"));
2391 }
2392 compaction_mode__ = Some(map_.next_value::<compaction_config::CompactionMode>()? as i32);
2393 }
2394 GeneratedField::CompressionAlgorithm => {
2395 if compression_algorithm__.is_some() {
2396 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
2397 }
2398 compression_algorithm__ = Some(map_.next_value()?);
2399 }
2400 GeneratedField::TargetFileSizeBase => {
2401 if target_file_size_base__.is_some() {
2402 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
2403 }
2404 target_file_size_base__ =
2405 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2406 ;
2407 }
2408 GeneratedField::CompactionFilterMask => {
2409 if compaction_filter_mask__.is_some() {
2410 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
2411 }
2412 compaction_filter_mask__ =
2413 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2414 ;
2415 }
2416 GeneratedField::MaxSubCompaction => {
2417 if max_sub_compaction__.is_some() {
2418 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
2419 }
2420 max_sub_compaction__ =
2421 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2422 ;
2423 }
2424 GeneratedField::MaxSpaceReclaimBytes => {
2425 if max_space_reclaim_bytes__.is_some() {
2426 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
2427 }
2428 max_space_reclaim_bytes__ =
2429 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2430 ;
2431 }
2432 GeneratedField::SplitByStateTable => {
2433 if split_by_state_table__.is_some() {
2434 return Err(serde::de::Error::duplicate_field("splitByStateTable"));
2435 }
2436 split_by_state_table__ = Some(map_.next_value()?);
2437 }
2438 GeneratedField::SplitWeightByVnode => {
2439 if split_weight_by_vnode__.is_some() {
2440 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
2441 }
2442 split_weight_by_vnode__ =
2443 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2444 ;
2445 }
2446 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
2447 if level0_stop_write_threshold_sub_level_number__.is_some() {
2448 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
2449 }
2450 level0_stop_write_threshold_sub_level_number__ =
2451 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2452 ;
2453 }
2454 GeneratedField::Level0MaxCompactFileNumber => {
2455 if level0_max_compact_file_number__.is_some() {
2456 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
2457 }
2458 level0_max_compact_file_number__ =
2459 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2460 ;
2461 }
2462 GeneratedField::Level0SubLevelCompactLevelCount => {
2463 if level0_sub_level_compact_level_count__.is_some() {
2464 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
2465 }
2466 level0_sub_level_compact_level_count__ =
2467 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2468 ;
2469 }
2470 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
2471 if level0_overlapping_sub_level_compact_level_count__.is_some() {
2472 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
2473 }
2474 level0_overlapping_sub_level_compact_level_count__ =
2475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2476 ;
2477 }
2478 GeneratedField::TombstoneReclaimRatio => {
2479 if tombstone_reclaim_ratio__.is_some() {
2480 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
2481 }
2482 tombstone_reclaim_ratio__ =
2483 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2484 ;
2485 }
2486 GeneratedField::EnableEmergencyPicker => {
2487 if enable_emergency_picker__.is_some() {
2488 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
2489 }
2490 enable_emergency_picker__ = Some(map_.next_value()?);
2491 }
2492 GeneratedField::MaxL0CompactLevelCount => {
2493 if max_l0_compact_level_count__.is_some() {
2494 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
2495 }
2496 max_l0_compact_level_count__ =
2497 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2498 ;
2499 }
2500 GeneratedField::SstAllowedTrivialMoveMinSize => {
2501 if sst_allowed_trivial_move_min_size__.is_some() {
2502 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
2503 }
2504 sst_allowed_trivial_move_min_size__ =
2505 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2506 ;
2507 }
2508 GeneratedField::DisableAutoGroupScheduling => {
2509 if disable_auto_group_scheduling__.is_some() {
2510 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
2511 }
2512 disable_auto_group_scheduling__ = map_.next_value()?;
2513 }
2514 GeneratedField::MaxOverlappingLevelSize => {
2515 if max_overlapping_level_size__.is_some() {
2516 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
2517 }
2518 max_overlapping_level_size__ =
2519 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2520 ;
2521 }
2522 GeneratedField::EmergencyLevel0SstFileCount => {
2523 if emergency_level0_sst_file_count__.is_some() {
2524 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
2525 }
2526 emergency_level0_sst_file_count__ =
2527 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2528 ;
2529 }
2530 GeneratedField::EmergencyLevel0SubLevelPartition => {
2531 if emergency_level0_sub_level_partition__.is_some() {
2532 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
2533 }
2534 emergency_level0_sub_level_partition__ =
2535 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2536 ;
2537 }
2538 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
2539 if level0_stop_write_threshold_max_sst_count__.is_some() {
2540 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
2541 }
2542 level0_stop_write_threshold_max_sst_count__ =
2543 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2544 ;
2545 }
2546 GeneratedField::Level0StopWriteThresholdMaxSize => {
2547 if level0_stop_write_threshold_max_size__.is_some() {
2548 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
2549 }
2550 level0_stop_write_threshold_max_size__ =
2551 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2552 ;
2553 }
2554 GeneratedField::SstAllowedTrivialMoveMaxCount => {
2555 if sst_allowed_trivial_move_max_count__.is_some() {
2556 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
2557 }
2558 sst_allowed_trivial_move_max_count__ =
2559 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2560 ;
2561 }
2562 GeneratedField::EnableOptimizeL0IntervalSelection => {
2563 if enable_optimize_l0_interval_selection__.is_some() {
2564 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
2565 }
2566 enable_optimize_l0_interval_selection__ = map_.next_value()?;
2567 }
2568 GeneratedField::VnodeAlignedLevelSizeThreshold => {
2569 if vnode_aligned_level_size_threshold__.is_some() {
2570 return Err(serde::de::Error::duplicate_field("vnodeAlignedLevelSizeThreshold"));
2571 }
2572 vnode_aligned_level_size_threshold__ =
2573 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2574 ;
2575 }
2576 GeneratedField::MaxKvCountForXor16 => {
2577 if max_kv_count_for_xor16__.is_some() {
2578 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
2579 }
2580 max_kv_count_for_xor16__ =
2581 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2582 ;
2583 }
2584 GeneratedField::MaxVnodeKeyRangeBytes => {
2585 if max_vnode_key_range_bytes__.is_some() {
2586 return Err(serde::de::Error::duplicate_field("maxVnodeKeyRangeBytes"));
2587 }
2588 max_vnode_key_range_bytes__ =
2589 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2590 ;
2591 }
2592 }
2593 }
2594 Ok(CompactionConfig {
2595 max_bytes_for_level_base: max_bytes_for_level_base__.unwrap_or_default(),
2596 max_level: max_level__.unwrap_or_default(),
2597 max_bytes_for_level_multiplier: max_bytes_for_level_multiplier__.unwrap_or_default(),
2598 max_compaction_bytes: max_compaction_bytes__.unwrap_or_default(),
2599 sub_level_max_compaction_bytes: sub_level_max_compaction_bytes__.unwrap_or_default(),
2600 level0_tier_compact_file_number: level0_tier_compact_file_number__.unwrap_or_default(),
2601 compaction_mode: compaction_mode__.unwrap_or_default(),
2602 compression_algorithm: compression_algorithm__.unwrap_or_default(),
2603 target_file_size_base: target_file_size_base__.unwrap_or_default(),
2604 compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
2605 max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
2606 max_space_reclaim_bytes: max_space_reclaim_bytes__.unwrap_or_default(),
2607 split_by_state_table: split_by_state_table__.unwrap_or_default(),
2608 split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
2609 level0_stop_write_threshold_sub_level_number: level0_stop_write_threshold_sub_level_number__.unwrap_or_default(),
2610 level0_max_compact_file_number: level0_max_compact_file_number__.unwrap_or_default(),
2611 level0_sub_level_compact_level_count: level0_sub_level_compact_level_count__.unwrap_or_default(),
2612 level0_overlapping_sub_level_compact_level_count: level0_overlapping_sub_level_compact_level_count__.unwrap_or_default(),
2613 tombstone_reclaim_ratio: tombstone_reclaim_ratio__.unwrap_or_default(),
2614 enable_emergency_picker: enable_emergency_picker__.unwrap_or_default(),
2615 max_l0_compact_level_count: max_l0_compact_level_count__,
2616 sst_allowed_trivial_move_min_size: sst_allowed_trivial_move_min_size__,
2617 disable_auto_group_scheduling: disable_auto_group_scheduling__,
2618 max_overlapping_level_size: max_overlapping_level_size__,
2619 emergency_level0_sst_file_count: emergency_level0_sst_file_count__,
2620 emergency_level0_sub_level_partition: emergency_level0_sub_level_partition__,
2621 level0_stop_write_threshold_max_sst_count: level0_stop_write_threshold_max_sst_count__,
2622 level0_stop_write_threshold_max_size: level0_stop_write_threshold_max_size__,
2623 sst_allowed_trivial_move_max_count: sst_allowed_trivial_move_max_count__,
2624 enable_optimize_l0_interval_selection: enable_optimize_l0_interval_selection__,
2625 vnode_aligned_level_size_threshold: vnode_aligned_level_size_threshold__,
2626 max_kv_count_for_xor16: max_kv_count_for_xor16__,
2627 max_vnode_key_range_bytes: max_vnode_key_range_bytes__,
2628 })
2629 }
2630 }
2631 deserializer.deserialize_struct("hummock.CompactionConfig", FIELDS, GeneratedVisitor)
2632 }
2633}
2634impl serde::Serialize for compaction_config::CompactionMode {
2635 #[allow(deprecated)]
2636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2637 where
2638 S: serde::Serializer,
2639 {
2640 let variant = match self {
2641 Self::Unspecified => "UNSPECIFIED",
2642 Self::Range => "RANGE",
2643 };
2644 serializer.serialize_str(variant)
2645 }
2646}
2647impl<'de> serde::Deserialize<'de> for compaction_config::CompactionMode {
2648 #[allow(deprecated)]
2649 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2650 where
2651 D: serde::Deserializer<'de>,
2652 {
2653 const FIELDS: &[&str] = &[
2654 "UNSPECIFIED",
2655 "RANGE",
2656 ];
2657
2658 struct GeneratedVisitor;
2659
2660 impl serde::de::Visitor<'_> for GeneratedVisitor {
2661 type Value = compaction_config::CompactionMode;
2662
2663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2664 write!(formatter, "expected one of: {:?}", &FIELDS)
2665 }
2666
2667 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2668 where
2669 E: serde::de::Error,
2670 {
2671 i32::try_from(v)
2672 .ok()
2673 .and_then(|x| x.try_into().ok())
2674 .ok_or_else(|| {
2675 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2676 })
2677 }
2678
2679 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2680 where
2681 E: serde::de::Error,
2682 {
2683 i32::try_from(v)
2684 .ok()
2685 .and_then(|x| x.try_into().ok())
2686 .ok_or_else(|| {
2687 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2688 })
2689 }
2690
2691 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2692 where
2693 E: serde::de::Error,
2694 {
2695 match value {
2696 "UNSPECIFIED" => Ok(compaction_config::CompactionMode::Unspecified),
2697 "RANGE" => Ok(compaction_config::CompactionMode::Range),
2698 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2699 }
2700 }
2701 }
2702 deserializer.deserialize_any(GeneratedVisitor)
2703 }
2704}
2705impl serde::Serialize for CompactionGroup {
2706 #[allow(deprecated)]
2707 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2708 where
2709 S: serde::Serializer,
2710 {
2711 use serde::ser::SerializeStruct;
2712 let mut len = 0;
2713 if self.id != 0 {
2714 len += 1;
2715 }
2716 if self.compaction_config.is_some() {
2717 len += 1;
2718 }
2719 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroup", len)?;
2720 if self.id != 0 {
2721 #[allow(clippy::needless_borrow)]
2722 #[allow(clippy::needless_borrows_for_generic_args)]
2723 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2724 }
2725 if let Some(v) = self.compaction_config.as_ref() {
2726 struct_ser.serialize_field("compactionConfig", v)?;
2727 }
2728 struct_ser.end()
2729 }
2730}
2731impl<'de> serde::Deserialize<'de> for CompactionGroup {
2732 #[allow(deprecated)]
2733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2734 where
2735 D: serde::Deserializer<'de>,
2736 {
2737 const FIELDS: &[&str] = &[
2738 "id",
2739 "compaction_config",
2740 "compactionConfig",
2741 ];
2742
2743 #[allow(clippy::enum_variant_names)]
2744 enum GeneratedField {
2745 Id,
2746 CompactionConfig,
2747 }
2748 impl<'de> serde::Deserialize<'de> for GeneratedField {
2749 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2750 where
2751 D: serde::Deserializer<'de>,
2752 {
2753 struct GeneratedVisitor;
2754
2755 impl serde::de::Visitor<'_> for GeneratedVisitor {
2756 type Value = GeneratedField;
2757
2758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2759 write!(formatter, "expected one of: {:?}", &FIELDS)
2760 }
2761
2762 #[allow(unused_variables)]
2763 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2764 where
2765 E: serde::de::Error,
2766 {
2767 match value {
2768 "id" => Ok(GeneratedField::Id),
2769 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2770 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2771 }
2772 }
2773 }
2774 deserializer.deserialize_identifier(GeneratedVisitor)
2775 }
2776 }
2777 struct GeneratedVisitor;
2778 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2779 type Value = CompactionGroup;
2780
2781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2782 formatter.write_str("struct hummock.CompactionGroup")
2783 }
2784
2785 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroup, V::Error>
2786 where
2787 V: serde::de::MapAccess<'de>,
2788 {
2789 let mut id__ = None;
2790 let mut compaction_config__ = None;
2791 while let Some(k) = map_.next_key()? {
2792 match k {
2793 GeneratedField::Id => {
2794 if id__.is_some() {
2795 return Err(serde::de::Error::duplicate_field("id"));
2796 }
2797 id__ =
2798 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2799 ;
2800 }
2801 GeneratedField::CompactionConfig => {
2802 if compaction_config__.is_some() {
2803 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2804 }
2805 compaction_config__ = map_.next_value()?;
2806 }
2807 }
2808 }
2809 Ok(CompactionGroup {
2810 id: id__.unwrap_or_default(),
2811 compaction_config: compaction_config__,
2812 })
2813 }
2814 }
2815 deserializer.deserialize_struct("hummock.CompactionGroup", FIELDS, GeneratedVisitor)
2816 }
2817}
2818impl serde::Serialize for CompactionGroupInfo {
2819 #[allow(deprecated)]
2820 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2821 where
2822 S: serde::Serializer,
2823 {
2824 use serde::ser::SerializeStruct;
2825 let mut len = 0;
2826 if self.id != 0 {
2827 len += 1;
2828 }
2829 if self.parent_id != 0 {
2830 len += 1;
2831 }
2832 if !self.member_table_ids.is_empty() {
2833 len += 1;
2834 }
2835 if self.compaction_config.is_some() {
2836 len += 1;
2837 }
2838 let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroupInfo", len)?;
2839 if self.id != 0 {
2840 #[allow(clippy::needless_borrow)]
2841 #[allow(clippy::needless_borrows_for_generic_args)]
2842 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2843 }
2844 if self.parent_id != 0 {
2845 #[allow(clippy::needless_borrow)]
2846 #[allow(clippy::needless_borrows_for_generic_args)]
2847 struct_ser.serialize_field("parentId", ToString::to_string(&self.parent_id).as_str())?;
2848 }
2849 if !self.member_table_ids.is_empty() {
2850 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
2851 }
2852 if let Some(v) = self.compaction_config.as_ref() {
2853 struct_ser.serialize_field("compactionConfig", v)?;
2854 }
2855 struct_ser.end()
2856 }
2857}
2858impl<'de> serde::Deserialize<'de> for CompactionGroupInfo {
2859 #[allow(deprecated)]
2860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2861 where
2862 D: serde::Deserializer<'de>,
2863 {
2864 const FIELDS: &[&str] = &[
2865 "id",
2866 "parent_id",
2867 "parentId",
2868 "member_table_ids",
2869 "memberTableIds",
2870 "compaction_config",
2871 "compactionConfig",
2872 ];
2873
2874 #[allow(clippy::enum_variant_names)]
2875 enum GeneratedField {
2876 Id,
2877 ParentId,
2878 MemberTableIds,
2879 CompactionConfig,
2880 }
2881 impl<'de> serde::Deserialize<'de> for GeneratedField {
2882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2883 where
2884 D: serde::Deserializer<'de>,
2885 {
2886 struct GeneratedVisitor;
2887
2888 impl serde::de::Visitor<'_> for GeneratedVisitor {
2889 type Value = GeneratedField;
2890
2891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2892 write!(formatter, "expected one of: {:?}", &FIELDS)
2893 }
2894
2895 #[allow(unused_variables)]
2896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2897 where
2898 E: serde::de::Error,
2899 {
2900 match value {
2901 "id" => Ok(GeneratedField::Id),
2902 "parentId" | "parent_id" => Ok(GeneratedField::ParentId),
2903 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
2904 "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2906 }
2907 }
2908 }
2909 deserializer.deserialize_identifier(GeneratedVisitor)
2910 }
2911 }
2912 struct GeneratedVisitor;
2913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2914 type Value = CompactionGroupInfo;
2915
2916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2917 formatter.write_str("struct hummock.CompactionGroupInfo")
2918 }
2919
2920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroupInfo, V::Error>
2921 where
2922 V: serde::de::MapAccess<'de>,
2923 {
2924 let mut id__ = None;
2925 let mut parent_id__ = None;
2926 let mut member_table_ids__ = None;
2927 let mut compaction_config__ = None;
2928 while let Some(k) = map_.next_key()? {
2929 match k {
2930 GeneratedField::Id => {
2931 if id__.is_some() {
2932 return Err(serde::de::Error::duplicate_field("id"));
2933 }
2934 id__ =
2935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2936 ;
2937 }
2938 GeneratedField::ParentId => {
2939 if parent_id__.is_some() {
2940 return Err(serde::de::Error::duplicate_field("parentId"));
2941 }
2942 parent_id__ =
2943 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2944 ;
2945 }
2946 GeneratedField::MemberTableIds => {
2947 if member_table_ids__.is_some() {
2948 return Err(serde::de::Error::duplicate_field("memberTableIds"));
2949 }
2950 member_table_ids__ =
2951 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2952 .into_iter().map(|x| x.0).collect())
2953 ;
2954 }
2955 GeneratedField::CompactionConfig => {
2956 if compaction_config__.is_some() {
2957 return Err(serde::de::Error::duplicate_field("compactionConfig"));
2958 }
2959 compaction_config__ = map_.next_value()?;
2960 }
2961 }
2962 }
2963 Ok(CompactionGroupInfo {
2964 id: id__.unwrap_or_default(),
2965 parent_id: parent_id__.unwrap_or_default(),
2966 member_table_ids: member_table_ids__.unwrap_or_default(),
2967 compaction_config: compaction_config__,
2968 })
2969 }
2970 }
2971 deserializer.deserialize_struct("hummock.CompactionGroupInfo", FIELDS, GeneratedVisitor)
2972 }
2973}
2974impl serde::Serialize for CompatibilityVersion {
2975 #[allow(deprecated)]
2976 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2977 where
2978 S: serde::Serializer,
2979 {
2980 let variant = match self {
2981 Self::VersionUnspecified => "VERSION_UNSPECIFIED",
2982 Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
2983 Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
2984 Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
2985 };
2986 serializer.serialize_str(variant)
2987 }
2988}
2989impl<'de> serde::Deserialize<'de> for CompatibilityVersion {
2990 #[allow(deprecated)]
2991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2992 where
2993 D: serde::Deserializer<'de>,
2994 {
2995 const FIELDS: &[&str] = &[
2996 "VERSION_UNSPECIFIED",
2997 "NO_TRIVIAL_SPLIT",
2998 "NO_MEMBER_TABLE_IDS",
2999 "SPLIT_GROUP_BY_TABLE_ID",
3000 ];
3001
3002 struct GeneratedVisitor;
3003
3004 impl serde::de::Visitor<'_> for GeneratedVisitor {
3005 type Value = CompatibilityVersion;
3006
3007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3008 write!(formatter, "expected one of: {:?}", &FIELDS)
3009 }
3010
3011 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3012 where
3013 E: serde::de::Error,
3014 {
3015 i32::try_from(v)
3016 .ok()
3017 .and_then(|x| x.try_into().ok())
3018 .ok_or_else(|| {
3019 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3020 })
3021 }
3022
3023 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3024 where
3025 E: serde::de::Error,
3026 {
3027 i32::try_from(v)
3028 .ok()
3029 .and_then(|x| x.try_into().ok())
3030 .ok_or_else(|| {
3031 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3032 })
3033 }
3034
3035 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3036 where
3037 E: serde::de::Error,
3038 {
3039 match value {
3040 "VERSION_UNSPECIFIED" => Ok(CompatibilityVersion::VersionUnspecified),
3041 "NO_TRIVIAL_SPLIT" => Ok(CompatibilityVersion::NoTrivialSplit),
3042 "NO_MEMBER_TABLE_IDS" => Ok(CompatibilityVersion::NoMemberTableIds),
3043 "SPLIT_GROUP_BY_TABLE_ID" => Ok(CompatibilityVersion::SplitGroupByTableId),
3044 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3045 }
3046 }
3047 }
3048 deserializer.deserialize_any(GeneratedVisitor)
3049 }
3050}
3051impl serde::Serialize for DisableCommitEpochRequest {
3052 #[allow(deprecated)]
3053 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3054 where
3055 S: serde::Serializer,
3056 {
3057 use serde::ser::SerializeStruct;
3058 let len = 0;
3059 let struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochRequest", len)?;
3060 struct_ser.end()
3061 }
3062}
3063impl<'de> serde::Deserialize<'de> for DisableCommitEpochRequest {
3064 #[allow(deprecated)]
3065 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3066 where
3067 D: serde::Deserializer<'de>,
3068 {
3069 const FIELDS: &[&str] = &[
3070 ];
3071
3072 #[allow(clippy::enum_variant_names)]
3073 enum GeneratedField {
3074 }
3075 impl<'de> serde::Deserialize<'de> for GeneratedField {
3076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3077 where
3078 D: serde::Deserializer<'de>,
3079 {
3080 struct GeneratedVisitor;
3081
3082 impl serde::de::Visitor<'_> for GeneratedVisitor {
3083 type Value = GeneratedField;
3084
3085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3086 write!(formatter, "expected one of: {:?}", &FIELDS)
3087 }
3088
3089 #[allow(unused_variables)]
3090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3091 where
3092 E: serde::de::Error,
3093 {
3094 Err(serde::de::Error::unknown_field(value, FIELDS))
3095 }
3096 }
3097 deserializer.deserialize_identifier(GeneratedVisitor)
3098 }
3099 }
3100 struct GeneratedVisitor;
3101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3102 type Value = DisableCommitEpochRequest;
3103
3104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3105 formatter.write_str("struct hummock.DisableCommitEpochRequest")
3106 }
3107
3108 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochRequest, V::Error>
3109 where
3110 V: serde::de::MapAccess<'de>,
3111 {
3112 while map_.next_key::<GeneratedField>()?.is_some() {
3113 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3114 }
3115 Ok(DisableCommitEpochRequest {
3116 })
3117 }
3118 }
3119 deserializer.deserialize_struct("hummock.DisableCommitEpochRequest", FIELDS, GeneratedVisitor)
3120 }
3121}
3122impl serde::Serialize for DisableCommitEpochResponse {
3123 #[allow(deprecated)]
3124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3125 where
3126 S: serde::Serializer,
3127 {
3128 use serde::ser::SerializeStruct;
3129 let mut len = 0;
3130 if self.current_version.is_some() {
3131 len += 1;
3132 }
3133 let mut struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochResponse", len)?;
3134 if let Some(v) = self.current_version.as_ref() {
3135 struct_ser.serialize_field("currentVersion", v)?;
3136 }
3137 struct_ser.end()
3138 }
3139}
3140impl<'de> serde::Deserialize<'de> for DisableCommitEpochResponse {
3141 #[allow(deprecated)]
3142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3143 where
3144 D: serde::Deserializer<'de>,
3145 {
3146 const FIELDS: &[&str] = &[
3147 "current_version",
3148 "currentVersion",
3149 ];
3150
3151 #[allow(clippy::enum_variant_names)]
3152 enum GeneratedField {
3153 CurrentVersion,
3154 }
3155 impl<'de> serde::Deserialize<'de> for GeneratedField {
3156 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3157 where
3158 D: serde::Deserializer<'de>,
3159 {
3160 struct GeneratedVisitor;
3161
3162 impl serde::de::Visitor<'_> for GeneratedVisitor {
3163 type Value = GeneratedField;
3164
3165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3166 write!(formatter, "expected one of: {:?}", &FIELDS)
3167 }
3168
3169 #[allow(unused_variables)]
3170 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3171 where
3172 E: serde::de::Error,
3173 {
3174 match value {
3175 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
3176 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3177 }
3178 }
3179 }
3180 deserializer.deserialize_identifier(GeneratedVisitor)
3181 }
3182 }
3183 struct GeneratedVisitor;
3184 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3185 type Value = DisableCommitEpochResponse;
3186
3187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3188 formatter.write_str("struct hummock.DisableCommitEpochResponse")
3189 }
3190
3191 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochResponse, V::Error>
3192 where
3193 V: serde::de::MapAccess<'de>,
3194 {
3195 let mut current_version__ = None;
3196 while let Some(k) = map_.next_key()? {
3197 match k {
3198 GeneratedField::CurrentVersion => {
3199 if current_version__.is_some() {
3200 return Err(serde::de::Error::duplicate_field("currentVersion"));
3201 }
3202 current_version__ = map_.next_value()?;
3203 }
3204 }
3205 }
3206 Ok(DisableCommitEpochResponse {
3207 current_version: current_version__,
3208 })
3209 }
3210 }
3211 deserializer.deserialize_struct("hummock.DisableCommitEpochResponse", FIELDS, GeneratedVisitor)
3212 }
3213}
3214impl serde::Serialize for EpochNewChangeLog {
3215 #[allow(deprecated)]
3216 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3217 where
3218 S: serde::Serializer,
3219 {
3220 use serde::ser::SerializeStruct;
3221 let mut len = 0;
3222 if !self.old_value.is_empty() {
3223 len += 1;
3224 }
3225 if !self.new_value.is_empty() {
3226 len += 1;
3227 }
3228 if !self.epochs.is_empty() {
3229 len += 1;
3230 }
3231 let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3232 if !self.old_value.is_empty() {
3233 struct_ser.serialize_field("oldValue", &self.old_value)?;
3234 }
3235 if !self.new_value.is_empty() {
3236 struct_ser.serialize_field("newValue", &self.new_value)?;
3237 }
3238 if !self.epochs.is_empty() {
3239 struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3240 }
3241 struct_ser.end()
3242 }
3243}
3244impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3245 #[allow(deprecated)]
3246 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3247 where
3248 D: serde::Deserializer<'de>,
3249 {
3250 const FIELDS: &[&str] = &[
3251 "old_value",
3252 "oldValue",
3253 "new_value",
3254 "newValue",
3255 "epochs",
3256 ];
3257
3258 #[allow(clippy::enum_variant_names)]
3259 enum GeneratedField {
3260 OldValue,
3261 NewValue,
3262 Epochs,
3263 }
3264 impl<'de> serde::Deserialize<'de> for GeneratedField {
3265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3266 where
3267 D: serde::Deserializer<'de>,
3268 {
3269 struct GeneratedVisitor;
3270
3271 impl serde::de::Visitor<'_> for GeneratedVisitor {
3272 type Value = GeneratedField;
3273
3274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3275 write!(formatter, "expected one of: {:?}", &FIELDS)
3276 }
3277
3278 #[allow(unused_variables)]
3279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3280 where
3281 E: serde::de::Error,
3282 {
3283 match value {
3284 "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3285 "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3286 "epochs" => Ok(GeneratedField::Epochs),
3287 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3288 }
3289 }
3290 }
3291 deserializer.deserialize_identifier(GeneratedVisitor)
3292 }
3293 }
3294 struct GeneratedVisitor;
3295 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3296 type Value = EpochNewChangeLog;
3297
3298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3299 formatter.write_str("struct hummock.EpochNewChangeLog")
3300 }
3301
3302 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3303 where
3304 V: serde::de::MapAccess<'de>,
3305 {
3306 let mut old_value__ = None;
3307 let mut new_value__ = None;
3308 let mut epochs__ = None;
3309 while let Some(k) = map_.next_key()? {
3310 match k {
3311 GeneratedField::OldValue => {
3312 if old_value__.is_some() {
3313 return Err(serde::de::Error::duplicate_field("oldValue"));
3314 }
3315 old_value__ = Some(map_.next_value()?);
3316 }
3317 GeneratedField::NewValue => {
3318 if new_value__.is_some() {
3319 return Err(serde::de::Error::duplicate_field("newValue"));
3320 }
3321 new_value__ = Some(map_.next_value()?);
3322 }
3323 GeneratedField::Epochs => {
3324 if epochs__.is_some() {
3325 return Err(serde::de::Error::duplicate_field("epochs"));
3326 }
3327 epochs__ =
3328 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3329 .into_iter().map(|x| x.0).collect())
3330 ;
3331 }
3332 }
3333 }
3334 Ok(EpochNewChangeLog {
3335 old_value: old_value__.unwrap_or_default(),
3336 new_value: new_value__.unwrap_or_default(),
3337 epochs: epochs__.unwrap_or_default(),
3338 })
3339 }
3340 }
3341 deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3342 }
3343}
3344impl serde::Serialize for FlatIndex {
3345 #[allow(deprecated)]
3346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3347 where
3348 S: serde::Serializer,
3349 {
3350 use serde::ser::SerializeStruct;
3351 let mut len = 0;
3352 if self.config.is_some() {
3353 len += 1;
3354 }
3355 if !self.vector_files.is_empty() {
3356 len += 1;
3357 }
3358 if self.next_vector_id != 0 {
3359 len += 1;
3360 }
3361 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3362 if let Some(v) = self.config.as_ref() {
3363 struct_ser.serialize_field("config", v)?;
3364 }
3365 if !self.vector_files.is_empty() {
3366 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3367 }
3368 if self.next_vector_id != 0 {
3369 #[allow(clippy::needless_borrow)]
3370 #[allow(clippy::needless_borrows_for_generic_args)]
3371 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3372 }
3373 struct_ser.end()
3374 }
3375}
3376impl<'de> serde::Deserialize<'de> for FlatIndex {
3377 #[allow(deprecated)]
3378 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3379 where
3380 D: serde::Deserializer<'de>,
3381 {
3382 const FIELDS: &[&str] = &[
3383 "config",
3384 "vector_files",
3385 "vectorFiles",
3386 "next_vector_id",
3387 "nextVectorId",
3388 ];
3389
3390 #[allow(clippy::enum_variant_names)]
3391 enum GeneratedField {
3392 Config,
3393 VectorFiles,
3394 NextVectorId,
3395 }
3396 impl<'de> serde::Deserialize<'de> for GeneratedField {
3397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3398 where
3399 D: serde::Deserializer<'de>,
3400 {
3401 struct GeneratedVisitor;
3402
3403 impl serde::de::Visitor<'_> for GeneratedVisitor {
3404 type Value = GeneratedField;
3405
3406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3407 write!(formatter, "expected one of: {:?}", &FIELDS)
3408 }
3409
3410 #[allow(unused_variables)]
3411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3412 where
3413 E: serde::de::Error,
3414 {
3415 match value {
3416 "config" => Ok(GeneratedField::Config),
3417 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3418 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3419 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3420 }
3421 }
3422 }
3423 deserializer.deserialize_identifier(GeneratedVisitor)
3424 }
3425 }
3426 struct GeneratedVisitor;
3427 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3428 type Value = FlatIndex;
3429
3430 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3431 formatter.write_str("struct hummock.FlatIndex")
3432 }
3433
3434 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3435 where
3436 V: serde::de::MapAccess<'de>,
3437 {
3438 let mut config__ = None;
3439 let mut vector_files__ = None;
3440 let mut next_vector_id__ = None;
3441 while let Some(k) = map_.next_key()? {
3442 match k {
3443 GeneratedField::Config => {
3444 if config__.is_some() {
3445 return Err(serde::de::Error::duplicate_field("config"));
3446 }
3447 config__ = map_.next_value()?;
3448 }
3449 GeneratedField::VectorFiles => {
3450 if vector_files__.is_some() {
3451 return Err(serde::de::Error::duplicate_field("vectorFiles"));
3452 }
3453 vector_files__ = Some(map_.next_value()?);
3454 }
3455 GeneratedField::NextVectorId => {
3456 if next_vector_id__.is_some() {
3457 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3458 }
3459 next_vector_id__ =
3460 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3461 ;
3462 }
3463 }
3464 }
3465 Ok(FlatIndex {
3466 config: config__,
3467 vector_files: vector_files__.unwrap_or_default(),
3468 next_vector_id: next_vector_id__.unwrap_or_default(),
3469 })
3470 }
3471 }
3472 deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3473 }
3474}
3475impl serde::Serialize for FlatIndexAdd {
3476 #[allow(deprecated)]
3477 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3478 where
3479 S: serde::Serializer,
3480 {
3481 use serde::ser::SerializeStruct;
3482 let mut len = 0;
3483 if !self.added_vector_files.is_empty() {
3484 len += 1;
3485 }
3486 if self.next_vector_id != 0 {
3487 len += 1;
3488 }
3489 let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3490 if !self.added_vector_files.is_empty() {
3491 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3492 }
3493 if self.next_vector_id != 0 {
3494 #[allow(clippy::needless_borrow)]
3495 #[allow(clippy::needless_borrows_for_generic_args)]
3496 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3497 }
3498 struct_ser.end()
3499 }
3500}
3501impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3502 #[allow(deprecated)]
3503 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3504 where
3505 D: serde::Deserializer<'de>,
3506 {
3507 const FIELDS: &[&str] = &[
3508 "added_vector_files",
3509 "addedVectorFiles",
3510 "next_vector_id",
3511 "nextVectorId",
3512 ];
3513
3514 #[allow(clippy::enum_variant_names)]
3515 enum GeneratedField {
3516 AddedVectorFiles,
3517 NextVectorId,
3518 }
3519 impl<'de> serde::Deserialize<'de> for GeneratedField {
3520 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3521 where
3522 D: serde::Deserializer<'de>,
3523 {
3524 struct GeneratedVisitor;
3525
3526 impl serde::de::Visitor<'_> for GeneratedVisitor {
3527 type Value = GeneratedField;
3528
3529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3530 write!(formatter, "expected one of: {:?}", &FIELDS)
3531 }
3532
3533 #[allow(unused_variables)]
3534 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3535 where
3536 E: serde::de::Error,
3537 {
3538 match value {
3539 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3540 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3541 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3542 }
3543 }
3544 }
3545 deserializer.deserialize_identifier(GeneratedVisitor)
3546 }
3547 }
3548 struct GeneratedVisitor;
3549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3550 type Value = FlatIndexAdd;
3551
3552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3553 formatter.write_str("struct hummock.FlatIndexAdd")
3554 }
3555
3556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3557 where
3558 V: serde::de::MapAccess<'de>,
3559 {
3560 let mut added_vector_files__ = None;
3561 let mut next_vector_id__ = None;
3562 while let Some(k) = map_.next_key()? {
3563 match k {
3564 GeneratedField::AddedVectorFiles => {
3565 if added_vector_files__.is_some() {
3566 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3567 }
3568 added_vector_files__ = Some(map_.next_value()?);
3569 }
3570 GeneratedField::NextVectorId => {
3571 if next_vector_id__.is_some() {
3572 return Err(serde::de::Error::duplicate_field("nextVectorId"));
3573 }
3574 next_vector_id__ =
3575 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3576 ;
3577 }
3578 }
3579 }
3580 Ok(FlatIndexAdd {
3581 added_vector_files: added_vector_files__.unwrap_or_default(),
3582 next_vector_id: next_vector_id__.unwrap_or_default(),
3583 })
3584 }
3585 }
3586 deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3587 }
3588}
3589impl serde::Serialize for FullScanTask {
3590 #[allow(deprecated)]
3591 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3592 where
3593 S: serde::Serializer,
3594 {
3595 use serde::ser::SerializeStruct;
3596 let mut len = 0;
3597 if self.sst_retention_watermark != 0 {
3598 len += 1;
3599 }
3600 if self.prefix.is_some() {
3601 len += 1;
3602 }
3603 if self.start_after.is_some() {
3604 len += 1;
3605 }
3606 if self.limit.is_some() {
3607 len += 1;
3608 }
3609 let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3610 if self.sst_retention_watermark != 0 {
3611 #[allow(clippy::needless_borrow)]
3612 #[allow(clippy::needless_borrows_for_generic_args)]
3613 struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3614 }
3615 if let Some(v) = self.prefix.as_ref() {
3616 struct_ser.serialize_field("prefix", v)?;
3617 }
3618 if let Some(v) = self.start_after.as_ref() {
3619 struct_ser.serialize_field("startAfter", v)?;
3620 }
3621 if let Some(v) = self.limit.as_ref() {
3622 #[allow(clippy::needless_borrow)]
3623 #[allow(clippy::needless_borrows_for_generic_args)]
3624 struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3625 }
3626 struct_ser.end()
3627 }
3628}
3629impl<'de> serde::Deserialize<'de> for FullScanTask {
3630 #[allow(deprecated)]
3631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3632 where
3633 D: serde::Deserializer<'de>,
3634 {
3635 const FIELDS: &[&str] = &[
3636 "sst_retention_watermark",
3637 "sstRetentionWatermark",
3638 "prefix",
3639 "start_after",
3640 "startAfter",
3641 "limit",
3642 ];
3643
3644 #[allow(clippy::enum_variant_names)]
3645 enum GeneratedField {
3646 SstRetentionWatermark,
3647 Prefix,
3648 StartAfter,
3649 Limit,
3650 }
3651 impl<'de> serde::Deserialize<'de> for GeneratedField {
3652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3653 where
3654 D: serde::Deserializer<'de>,
3655 {
3656 struct GeneratedVisitor;
3657
3658 impl serde::de::Visitor<'_> for GeneratedVisitor {
3659 type Value = GeneratedField;
3660
3661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3662 write!(formatter, "expected one of: {:?}", &FIELDS)
3663 }
3664
3665 #[allow(unused_variables)]
3666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3667 where
3668 E: serde::de::Error,
3669 {
3670 match value {
3671 "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3672 "prefix" => Ok(GeneratedField::Prefix),
3673 "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3674 "limit" => Ok(GeneratedField::Limit),
3675 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3676 }
3677 }
3678 }
3679 deserializer.deserialize_identifier(GeneratedVisitor)
3680 }
3681 }
3682 struct GeneratedVisitor;
3683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3684 type Value = FullScanTask;
3685
3686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3687 formatter.write_str("struct hummock.FullScanTask")
3688 }
3689
3690 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3691 where
3692 V: serde::de::MapAccess<'de>,
3693 {
3694 let mut sst_retention_watermark__ = None;
3695 let mut prefix__ = None;
3696 let mut start_after__ = None;
3697 let mut limit__ = None;
3698 while let Some(k) = map_.next_key()? {
3699 match k {
3700 GeneratedField::SstRetentionWatermark => {
3701 if sst_retention_watermark__.is_some() {
3702 return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3703 }
3704 sst_retention_watermark__ =
3705 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3706 ;
3707 }
3708 GeneratedField::Prefix => {
3709 if prefix__.is_some() {
3710 return Err(serde::de::Error::duplicate_field("prefix"));
3711 }
3712 prefix__ = map_.next_value()?;
3713 }
3714 GeneratedField::StartAfter => {
3715 if start_after__.is_some() {
3716 return Err(serde::de::Error::duplicate_field("startAfter"));
3717 }
3718 start_after__ = map_.next_value()?;
3719 }
3720 GeneratedField::Limit => {
3721 if limit__.is_some() {
3722 return Err(serde::de::Error::duplicate_field("limit"));
3723 }
3724 limit__ =
3725 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3726 ;
3727 }
3728 }
3729 }
3730 Ok(FullScanTask {
3731 sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3732 prefix: prefix__,
3733 start_after: start_after__,
3734 limit: limit__,
3735 })
3736 }
3737 }
3738 deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3739 }
3740}
3741impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3742 #[allow(deprecated)]
3743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3744 where
3745 S: serde::Serializer,
3746 {
3747 use serde::ser::SerializeStruct;
3748 let len = 0;
3749 let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3750 struct_ser.end()
3751 }
3752}
3753impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3754 #[allow(deprecated)]
3755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3756 where
3757 D: serde::Deserializer<'de>,
3758 {
3759 const FIELDS: &[&str] = &[
3760 ];
3761
3762 #[allow(clippy::enum_variant_names)]
3763 enum GeneratedField {
3764 }
3765 impl<'de> serde::Deserialize<'de> for GeneratedField {
3766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3767 where
3768 D: serde::Deserializer<'de>,
3769 {
3770 struct GeneratedVisitor;
3771
3772 impl serde::de::Visitor<'_> for GeneratedVisitor {
3773 type Value = GeneratedField;
3774
3775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3776 write!(formatter, "expected one of: {:?}", &FIELDS)
3777 }
3778
3779 #[allow(unused_variables)]
3780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3781 where
3782 E: serde::de::Error,
3783 {
3784 Err(serde::de::Error::unknown_field(value, FIELDS))
3785 }
3786 }
3787 deserializer.deserialize_identifier(GeneratedVisitor)
3788 }
3789 }
3790 struct GeneratedVisitor;
3791 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3792 type Value = GetAssignedCompactTaskNumRequest;
3793
3794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3795 formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3796 }
3797
3798 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3799 where
3800 V: serde::de::MapAccess<'de>,
3801 {
3802 while map_.next_key::<GeneratedField>()?.is_some() {
3803 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3804 }
3805 Ok(GetAssignedCompactTaskNumRequest {
3806 })
3807 }
3808 }
3809 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3810 }
3811}
3812impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3813 #[allow(deprecated)]
3814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3815 where
3816 S: serde::Serializer,
3817 {
3818 use serde::ser::SerializeStruct;
3819 let mut len = 0;
3820 if self.num_tasks != 0 {
3821 len += 1;
3822 }
3823 let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3824 if self.num_tasks != 0 {
3825 struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3826 }
3827 struct_ser.end()
3828 }
3829}
3830impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3831 #[allow(deprecated)]
3832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3833 where
3834 D: serde::Deserializer<'de>,
3835 {
3836 const FIELDS: &[&str] = &[
3837 "num_tasks",
3838 "numTasks",
3839 ];
3840
3841 #[allow(clippy::enum_variant_names)]
3842 enum GeneratedField {
3843 NumTasks,
3844 }
3845 impl<'de> serde::Deserialize<'de> for GeneratedField {
3846 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3847 where
3848 D: serde::Deserializer<'de>,
3849 {
3850 struct GeneratedVisitor;
3851
3852 impl serde::de::Visitor<'_> for GeneratedVisitor {
3853 type Value = GeneratedField;
3854
3855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3856 write!(formatter, "expected one of: {:?}", &FIELDS)
3857 }
3858
3859 #[allow(unused_variables)]
3860 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3861 where
3862 E: serde::de::Error,
3863 {
3864 match value {
3865 "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3866 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3867 }
3868 }
3869 }
3870 deserializer.deserialize_identifier(GeneratedVisitor)
3871 }
3872 }
3873 struct GeneratedVisitor;
3874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3875 type Value = GetAssignedCompactTaskNumResponse;
3876
3877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3878 formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3879 }
3880
3881 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3882 where
3883 V: serde::de::MapAccess<'de>,
3884 {
3885 let mut num_tasks__ = None;
3886 while let Some(k) = map_.next_key()? {
3887 match k {
3888 GeneratedField::NumTasks => {
3889 if num_tasks__.is_some() {
3890 return Err(serde::de::Error::duplicate_field("numTasks"));
3891 }
3892 num_tasks__ =
3893 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3894 ;
3895 }
3896 }
3897 }
3898 Ok(GetAssignedCompactTaskNumResponse {
3899 num_tasks: num_tasks__.unwrap_or_default(),
3900 })
3901 }
3902 }
3903 deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3904 }
3905}
3906impl serde::Serialize for GetCompactionScoreRequest {
3907 #[allow(deprecated)]
3908 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3909 where
3910 S: serde::Serializer,
3911 {
3912 use serde::ser::SerializeStruct;
3913 let mut len = 0;
3914 if self.compaction_group_id != 0 {
3915 len += 1;
3916 }
3917 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3918 if self.compaction_group_id != 0 {
3919 #[allow(clippy::needless_borrow)]
3920 #[allow(clippy::needless_borrows_for_generic_args)]
3921 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3922 }
3923 struct_ser.end()
3924 }
3925}
3926impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3927 #[allow(deprecated)]
3928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3929 where
3930 D: serde::Deserializer<'de>,
3931 {
3932 const FIELDS: &[&str] = &[
3933 "compaction_group_id",
3934 "compactionGroupId",
3935 ];
3936
3937 #[allow(clippy::enum_variant_names)]
3938 enum GeneratedField {
3939 CompactionGroupId,
3940 }
3941 impl<'de> serde::Deserialize<'de> for GeneratedField {
3942 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3943 where
3944 D: serde::Deserializer<'de>,
3945 {
3946 struct GeneratedVisitor;
3947
3948 impl serde::de::Visitor<'_> for GeneratedVisitor {
3949 type Value = GeneratedField;
3950
3951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3952 write!(formatter, "expected one of: {:?}", &FIELDS)
3953 }
3954
3955 #[allow(unused_variables)]
3956 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3957 where
3958 E: serde::de::Error,
3959 {
3960 match value {
3961 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3963 }
3964 }
3965 }
3966 deserializer.deserialize_identifier(GeneratedVisitor)
3967 }
3968 }
3969 struct GeneratedVisitor;
3970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3971 type Value = GetCompactionScoreRequest;
3972
3973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3974 formatter.write_str("struct hummock.GetCompactionScoreRequest")
3975 }
3976
3977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3978 where
3979 V: serde::de::MapAccess<'de>,
3980 {
3981 let mut compaction_group_id__ = None;
3982 while let Some(k) = map_.next_key()? {
3983 match k {
3984 GeneratedField::CompactionGroupId => {
3985 if compaction_group_id__.is_some() {
3986 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3987 }
3988 compaction_group_id__ =
3989 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3990 ;
3991 }
3992 }
3993 }
3994 Ok(GetCompactionScoreRequest {
3995 compaction_group_id: compaction_group_id__.unwrap_or_default(),
3996 })
3997 }
3998 }
3999 deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
4000 }
4001}
4002impl serde::Serialize for GetCompactionScoreResponse {
4003 #[allow(deprecated)]
4004 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4005 where
4006 S: serde::Serializer,
4007 {
4008 use serde::ser::SerializeStruct;
4009 let mut len = 0;
4010 if self.compaction_group_id != 0 {
4011 len += 1;
4012 }
4013 if !self.scores.is_empty() {
4014 len += 1;
4015 }
4016 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
4017 if self.compaction_group_id != 0 {
4018 #[allow(clippy::needless_borrow)]
4019 #[allow(clippy::needless_borrows_for_generic_args)]
4020 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
4021 }
4022 if !self.scores.is_empty() {
4023 struct_ser.serialize_field("scores", &self.scores)?;
4024 }
4025 struct_ser.end()
4026 }
4027}
4028impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
4029 #[allow(deprecated)]
4030 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4031 where
4032 D: serde::Deserializer<'de>,
4033 {
4034 const FIELDS: &[&str] = &[
4035 "compaction_group_id",
4036 "compactionGroupId",
4037 "scores",
4038 ];
4039
4040 #[allow(clippy::enum_variant_names)]
4041 enum GeneratedField {
4042 CompactionGroupId,
4043 Scores,
4044 }
4045 impl<'de> serde::Deserialize<'de> for GeneratedField {
4046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4047 where
4048 D: serde::Deserializer<'de>,
4049 {
4050 struct GeneratedVisitor;
4051
4052 impl serde::de::Visitor<'_> for GeneratedVisitor {
4053 type Value = GeneratedField;
4054
4055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4056 write!(formatter, "expected one of: {:?}", &FIELDS)
4057 }
4058
4059 #[allow(unused_variables)]
4060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4061 where
4062 E: serde::de::Error,
4063 {
4064 match value {
4065 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
4066 "scores" => Ok(GeneratedField::Scores),
4067 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4068 }
4069 }
4070 }
4071 deserializer.deserialize_identifier(GeneratedVisitor)
4072 }
4073 }
4074 struct GeneratedVisitor;
4075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4076 type Value = GetCompactionScoreResponse;
4077
4078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4079 formatter.write_str("struct hummock.GetCompactionScoreResponse")
4080 }
4081
4082 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
4083 where
4084 V: serde::de::MapAccess<'de>,
4085 {
4086 let mut compaction_group_id__ = None;
4087 let mut scores__ = None;
4088 while let Some(k) = map_.next_key()? {
4089 match k {
4090 GeneratedField::CompactionGroupId => {
4091 if compaction_group_id__.is_some() {
4092 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
4093 }
4094 compaction_group_id__ =
4095 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4096 ;
4097 }
4098 GeneratedField::Scores => {
4099 if scores__.is_some() {
4100 return Err(serde::de::Error::duplicate_field("scores"));
4101 }
4102 scores__ = Some(map_.next_value()?);
4103 }
4104 }
4105 }
4106 Ok(GetCompactionScoreResponse {
4107 compaction_group_id: compaction_group_id__.unwrap_or_default(),
4108 scores: scores__.unwrap_or_default(),
4109 })
4110 }
4111 }
4112 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
4113 }
4114}
4115impl serde::Serialize for get_compaction_score_response::PickerInfo {
4116 #[allow(deprecated)]
4117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4118 where
4119 S: serde::Serializer,
4120 {
4121 use serde::ser::SerializeStruct;
4122 let mut len = 0;
4123 if self.score != 0 {
4124 len += 1;
4125 }
4126 if self.select_level != 0 {
4127 len += 1;
4128 }
4129 if self.target_level != 0 {
4130 len += 1;
4131 }
4132 if !self.picker_type.is_empty() {
4133 len += 1;
4134 }
4135 let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
4136 if self.score != 0 {
4137 #[allow(clippy::needless_borrow)]
4138 #[allow(clippy::needless_borrows_for_generic_args)]
4139 struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
4140 }
4141 if self.select_level != 0 {
4142 #[allow(clippy::needless_borrow)]
4143 #[allow(clippy::needless_borrows_for_generic_args)]
4144 struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
4145 }
4146 if self.target_level != 0 {
4147 #[allow(clippy::needless_borrow)]
4148 #[allow(clippy::needless_borrows_for_generic_args)]
4149 struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
4150 }
4151 if !self.picker_type.is_empty() {
4152 struct_ser.serialize_field("pickerType", &self.picker_type)?;
4153 }
4154 struct_ser.end()
4155 }
4156}
4157impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
4158 #[allow(deprecated)]
4159 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4160 where
4161 D: serde::Deserializer<'de>,
4162 {
4163 const FIELDS: &[&str] = &[
4164 "score",
4165 "select_level",
4166 "selectLevel",
4167 "target_level",
4168 "targetLevel",
4169 "picker_type",
4170 "pickerType",
4171 ];
4172
4173 #[allow(clippy::enum_variant_names)]
4174 enum GeneratedField {
4175 Score,
4176 SelectLevel,
4177 TargetLevel,
4178 PickerType,
4179 }
4180 impl<'de> serde::Deserialize<'de> for GeneratedField {
4181 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4182 where
4183 D: serde::Deserializer<'de>,
4184 {
4185 struct GeneratedVisitor;
4186
4187 impl serde::de::Visitor<'_> for GeneratedVisitor {
4188 type Value = GeneratedField;
4189
4190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4191 write!(formatter, "expected one of: {:?}", &FIELDS)
4192 }
4193
4194 #[allow(unused_variables)]
4195 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4196 where
4197 E: serde::de::Error,
4198 {
4199 match value {
4200 "score" => Ok(GeneratedField::Score),
4201 "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4202 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4203 "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4204 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4205 }
4206 }
4207 }
4208 deserializer.deserialize_identifier(GeneratedVisitor)
4209 }
4210 }
4211 struct GeneratedVisitor;
4212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4213 type Value = get_compaction_score_response::PickerInfo;
4214
4215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4216 formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4217 }
4218
4219 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4220 where
4221 V: serde::de::MapAccess<'de>,
4222 {
4223 let mut score__ = None;
4224 let mut select_level__ = None;
4225 let mut target_level__ = None;
4226 let mut picker_type__ = None;
4227 while let Some(k) = map_.next_key()? {
4228 match k {
4229 GeneratedField::Score => {
4230 if score__.is_some() {
4231 return Err(serde::de::Error::duplicate_field("score"));
4232 }
4233 score__ =
4234 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4235 ;
4236 }
4237 GeneratedField::SelectLevel => {
4238 if select_level__.is_some() {
4239 return Err(serde::de::Error::duplicate_field("selectLevel"));
4240 }
4241 select_level__ =
4242 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4243 ;
4244 }
4245 GeneratedField::TargetLevel => {
4246 if target_level__.is_some() {
4247 return Err(serde::de::Error::duplicate_field("targetLevel"));
4248 }
4249 target_level__ =
4250 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4251 ;
4252 }
4253 GeneratedField::PickerType => {
4254 if picker_type__.is_some() {
4255 return Err(serde::de::Error::duplicate_field("pickerType"));
4256 }
4257 picker_type__ = Some(map_.next_value()?);
4258 }
4259 }
4260 }
4261 Ok(get_compaction_score_response::PickerInfo {
4262 score: score__.unwrap_or_default(),
4263 select_level: select_level__.unwrap_or_default(),
4264 target_level: target_level__.unwrap_or_default(),
4265 picker_type: picker_type__.unwrap_or_default(),
4266 })
4267 }
4268 }
4269 deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4270 }
4271}
4272impl serde::Serialize for GetCurrentVersionRequest {
4273 #[allow(deprecated)]
4274 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4275 where
4276 S: serde::Serializer,
4277 {
4278 use serde::ser::SerializeStruct;
4279 let len = 0;
4280 let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4281 struct_ser.end()
4282 }
4283}
4284impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4285 #[allow(deprecated)]
4286 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4287 where
4288 D: serde::Deserializer<'de>,
4289 {
4290 const FIELDS: &[&str] = &[
4291 ];
4292
4293 #[allow(clippy::enum_variant_names)]
4294 enum GeneratedField {
4295 }
4296 impl<'de> serde::Deserialize<'de> for GeneratedField {
4297 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4298 where
4299 D: serde::Deserializer<'de>,
4300 {
4301 struct GeneratedVisitor;
4302
4303 impl serde::de::Visitor<'_> for GeneratedVisitor {
4304 type Value = GeneratedField;
4305
4306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4307 write!(formatter, "expected one of: {:?}", &FIELDS)
4308 }
4309
4310 #[allow(unused_variables)]
4311 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4312 where
4313 E: serde::de::Error,
4314 {
4315 Err(serde::de::Error::unknown_field(value, FIELDS))
4316 }
4317 }
4318 deserializer.deserialize_identifier(GeneratedVisitor)
4319 }
4320 }
4321 struct GeneratedVisitor;
4322 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4323 type Value = GetCurrentVersionRequest;
4324
4325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4326 formatter.write_str("struct hummock.GetCurrentVersionRequest")
4327 }
4328
4329 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4330 where
4331 V: serde::de::MapAccess<'de>,
4332 {
4333 while map_.next_key::<GeneratedField>()?.is_some() {
4334 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4335 }
4336 Ok(GetCurrentVersionRequest {
4337 })
4338 }
4339 }
4340 deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4341 }
4342}
4343impl serde::Serialize for GetCurrentVersionResponse {
4344 #[allow(deprecated)]
4345 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4346 where
4347 S: serde::Serializer,
4348 {
4349 use serde::ser::SerializeStruct;
4350 let mut len = 0;
4351 if self.status.is_some() {
4352 len += 1;
4353 }
4354 if self.current_version.is_some() {
4355 len += 1;
4356 }
4357 let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4358 if let Some(v) = self.status.as_ref() {
4359 struct_ser.serialize_field("status", v)?;
4360 }
4361 if let Some(v) = self.current_version.as_ref() {
4362 struct_ser.serialize_field("currentVersion", v)?;
4363 }
4364 struct_ser.end()
4365 }
4366}
4367impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4368 #[allow(deprecated)]
4369 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4370 where
4371 D: serde::Deserializer<'de>,
4372 {
4373 const FIELDS: &[&str] = &[
4374 "status",
4375 "current_version",
4376 "currentVersion",
4377 ];
4378
4379 #[allow(clippy::enum_variant_names)]
4380 enum GeneratedField {
4381 Status,
4382 CurrentVersion,
4383 }
4384 impl<'de> serde::Deserialize<'de> for GeneratedField {
4385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4386 where
4387 D: serde::Deserializer<'de>,
4388 {
4389 struct GeneratedVisitor;
4390
4391 impl serde::de::Visitor<'_> for GeneratedVisitor {
4392 type Value = GeneratedField;
4393
4394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4395 write!(formatter, "expected one of: {:?}", &FIELDS)
4396 }
4397
4398 #[allow(unused_variables)]
4399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4400 where
4401 E: serde::de::Error,
4402 {
4403 match value {
4404 "status" => Ok(GeneratedField::Status),
4405 "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4407 }
4408 }
4409 }
4410 deserializer.deserialize_identifier(GeneratedVisitor)
4411 }
4412 }
4413 struct GeneratedVisitor;
4414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4415 type Value = GetCurrentVersionResponse;
4416
4417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4418 formatter.write_str("struct hummock.GetCurrentVersionResponse")
4419 }
4420
4421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4422 where
4423 V: serde::de::MapAccess<'de>,
4424 {
4425 let mut status__ = None;
4426 let mut current_version__ = None;
4427 while let Some(k) = map_.next_key()? {
4428 match k {
4429 GeneratedField::Status => {
4430 if status__.is_some() {
4431 return Err(serde::de::Error::duplicate_field("status"));
4432 }
4433 status__ = map_.next_value()?;
4434 }
4435 GeneratedField::CurrentVersion => {
4436 if current_version__.is_some() {
4437 return Err(serde::de::Error::duplicate_field("currentVersion"));
4438 }
4439 current_version__ = map_.next_value()?;
4440 }
4441 }
4442 }
4443 Ok(GetCurrentVersionResponse {
4444 status: status__,
4445 current_version: current_version__,
4446 })
4447 }
4448 }
4449 deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4450 }
4451}
4452impl serde::Serialize for GetNewObjectIdsRequest {
4453 #[allow(deprecated)]
4454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4455 where
4456 S: serde::Serializer,
4457 {
4458 use serde::ser::SerializeStruct;
4459 let mut len = 0;
4460 if self.number != 0 {
4461 len += 1;
4462 }
4463 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4464 if self.number != 0 {
4465 struct_ser.serialize_field("number", &self.number)?;
4466 }
4467 struct_ser.end()
4468 }
4469}
4470impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4471 #[allow(deprecated)]
4472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4473 where
4474 D: serde::Deserializer<'de>,
4475 {
4476 const FIELDS: &[&str] = &[
4477 "number",
4478 ];
4479
4480 #[allow(clippy::enum_variant_names)]
4481 enum GeneratedField {
4482 Number,
4483 }
4484 impl<'de> serde::Deserialize<'de> for GeneratedField {
4485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4486 where
4487 D: serde::Deserializer<'de>,
4488 {
4489 struct GeneratedVisitor;
4490
4491 impl serde::de::Visitor<'_> for GeneratedVisitor {
4492 type Value = GeneratedField;
4493
4494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4495 write!(formatter, "expected one of: {:?}", &FIELDS)
4496 }
4497
4498 #[allow(unused_variables)]
4499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4500 where
4501 E: serde::de::Error,
4502 {
4503 match value {
4504 "number" => Ok(GeneratedField::Number),
4505 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4506 }
4507 }
4508 }
4509 deserializer.deserialize_identifier(GeneratedVisitor)
4510 }
4511 }
4512 struct GeneratedVisitor;
4513 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4514 type Value = GetNewObjectIdsRequest;
4515
4516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4517 formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4518 }
4519
4520 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4521 where
4522 V: serde::de::MapAccess<'de>,
4523 {
4524 let mut number__ = None;
4525 while let Some(k) = map_.next_key()? {
4526 match k {
4527 GeneratedField::Number => {
4528 if number__.is_some() {
4529 return Err(serde::de::Error::duplicate_field("number"));
4530 }
4531 number__ =
4532 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4533 ;
4534 }
4535 }
4536 }
4537 Ok(GetNewObjectIdsRequest {
4538 number: number__.unwrap_or_default(),
4539 })
4540 }
4541 }
4542 deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4543 }
4544}
4545impl serde::Serialize for GetNewObjectIdsResponse {
4546 #[allow(deprecated)]
4547 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4548 where
4549 S: serde::Serializer,
4550 {
4551 use serde::ser::SerializeStruct;
4552 let mut len = 0;
4553 if self.status.is_some() {
4554 len += 1;
4555 }
4556 if self.start_id != 0 {
4557 len += 1;
4558 }
4559 if self.end_id != 0 {
4560 len += 1;
4561 }
4562 let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4563 if let Some(v) = self.status.as_ref() {
4564 struct_ser.serialize_field("status", v)?;
4565 }
4566 if self.start_id != 0 {
4567 #[allow(clippy::needless_borrow)]
4568 #[allow(clippy::needless_borrows_for_generic_args)]
4569 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4570 }
4571 if self.end_id != 0 {
4572 #[allow(clippy::needless_borrow)]
4573 #[allow(clippy::needless_borrows_for_generic_args)]
4574 struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4575 }
4576 struct_ser.end()
4577 }
4578}
4579impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4580 #[allow(deprecated)]
4581 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4582 where
4583 D: serde::Deserializer<'de>,
4584 {
4585 const FIELDS: &[&str] = &[
4586 "status",
4587 "start_id",
4588 "startId",
4589 "end_id",
4590 "endId",
4591 ];
4592
4593 #[allow(clippy::enum_variant_names)]
4594 enum GeneratedField {
4595 Status,
4596 StartId,
4597 EndId,
4598 }
4599 impl<'de> serde::Deserialize<'de> for GeneratedField {
4600 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4601 where
4602 D: serde::Deserializer<'de>,
4603 {
4604 struct GeneratedVisitor;
4605
4606 impl serde::de::Visitor<'_> for GeneratedVisitor {
4607 type Value = GeneratedField;
4608
4609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4610 write!(formatter, "expected one of: {:?}", &FIELDS)
4611 }
4612
4613 #[allow(unused_variables)]
4614 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4615 where
4616 E: serde::de::Error,
4617 {
4618 match value {
4619 "status" => Ok(GeneratedField::Status),
4620 "startId" | "start_id" => Ok(GeneratedField::StartId),
4621 "endId" | "end_id" => Ok(GeneratedField::EndId),
4622 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4623 }
4624 }
4625 }
4626 deserializer.deserialize_identifier(GeneratedVisitor)
4627 }
4628 }
4629 struct GeneratedVisitor;
4630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4631 type Value = GetNewObjectIdsResponse;
4632
4633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4634 formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4635 }
4636
4637 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4638 where
4639 V: serde::de::MapAccess<'de>,
4640 {
4641 let mut status__ = None;
4642 let mut start_id__ = None;
4643 let mut end_id__ = None;
4644 while let Some(k) = map_.next_key()? {
4645 match k {
4646 GeneratedField::Status => {
4647 if status__.is_some() {
4648 return Err(serde::de::Error::duplicate_field("status"));
4649 }
4650 status__ = map_.next_value()?;
4651 }
4652 GeneratedField::StartId => {
4653 if start_id__.is_some() {
4654 return Err(serde::de::Error::duplicate_field("startId"));
4655 }
4656 start_id__ =
4657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4658 ;
4659 }
4660 GeneratedField::EndId => {
4661 if end_id__.is_some() {
4662 return Err(serde::de::Error::duplicate_field("endId"));
4663 }
4664 end_id__ =
4665 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4666 ;
4667 }
4668 }
4669 }
4670 Ok(GetNewObjectIdsResponse {
4671 status: status__,
4672 start_id: start_id__.unwrap_or_default(),
4673 end_id: end_id__.unwrap_or_default(),
4674 })
4675 }
4676 }
4677 deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4678 }
4679}
4680impl serde::Serialize for GetTableChangeLogsRequest {
4681 #[allow(deprecated)]
4682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4683 where
4684 S: serde::Serializer,
4685 {
4686 use serde::ser::SerializeStruct;
4687 let mut len = 0;
4688 if self.epoch_only {
4689 len += 1;
4690 }
4691 if self.exclude_empty {
4692 len += 1;
4693 }
4694 if self.start_epoch_inclusive.is_some() {
4695 len += 1;
4696 }
4697 if self.end_epoch_inclusive.is_some() {
4698 len += 1;
4699 }
4700 if self.table_ids.is_some() {
4701 len += 1;
4702 }
4703 if self.limit.is_some() {
4704 len += 1;
4705 }
4706 let mut struct_ser = serializer.serialize_struct("hummock.GetTableChangeLogsRequest", len)?;
4707 if self.epoch_only {
4708 struct_ser.serialize_field("epochOnly", &self.epoch_only)?;
4709 }
4710 if self.exclude_empty {
4711 struct_ser.serialize_field("excludeEmpty", &self.exclude_empty)?;
4712 }
4713 if let Some(v) = self.start_epoch_inclusive.as_ref() {
4714 #[allow(clippy::needless_borrow)]
4715 #[allow(clippy::needless_borrows_for_generic_args)]
4716 struct_ser.serialize_field("startEpochInclusive", ToString::to_string(&v).as_str())?;
4717 }
4718 if let Some(v) = self.end_epoch_inclusive.as_ref() {
4719 #[allow(clippy::needless_borrow)]
4720 #[allow(clippy::needless_borrows_for_generic_args)]
4721 struct_ser.serialize_field("endEpochInclusive", ToString::to_string(&v).as_str())?;
4722 }
4723 if let Some(v) = self.table_ids.as_ref() {
4724 struct_ser.serialize_field("tableIds", v)?;
4725 }
4726 if let Some(v) = self.limit.as_ref() {
4727 struct_ser.serialize_field("limit", v)?;
4728 }
4729 struct_ser.end()
4730 }
4731}
4732impl<'de> serde::Deserialize<'de> for GetTableChangeLogsRequest {
4733 #[allow(deprecated)]
4734 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4735 where
4736 D: serde::Deserializer<'de>,
4737 {
4738 const FIELDS: &[&str] = &[
4739 "epoch_only",
4740 "epochOnly",
4741 "exclude_empty",
4742 "excludeEmpty",
4743 "start_epoch_inclusive",
4744 "startEpochInclusive",
4745 "end_epoch_inclusive",
4746 "endEpochInclusive",
4747 "table_ids",
4748 "tableIds",
4749 "limit",
4750 ];
4751
4752 #[allow(clippy::enum_variant_names)]
4753 enum GeneratedField {
4754 EpochOnly,
4755 ExcludeEmpty,
4756 StartEpochInclusive,
4757 EndEpochInclusive,
4758 TableIds,
4759 Limit,
4760 }
4761 impl<'de> serde::Deserialize<'de> for GeneratedField {
4762 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4763 where
4764 D: serde::Deserializer<'de>,
4765 {
4766 struct GeneratedVisitor;
4767
4768 impl serde::de::Visitor<'_> for GeneratedVisitor {
4769 type Value = GeneratedField;
4770
4771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4772 write!(formatter, "expected one of: {:?}", &FIELDS)
4773 }
4774
4775 #[allow(unused_variables)]
4776 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4777 where
4778 E: serde::de::Error,
4779 {
4780 match value {
4781 "epochOnly" | "epoch_only" => Ok(GeneratedField::EpochOnly),
4782 "excludeEmpty" | "exclude_empty" => Ok(GeneratedField::ExcludeEmpty),
4783 "startEpochInclusive" | "start_epoch_inclusive" => Ok(GeneratedField::StartEpochInclusive),
4784 "endEpochInclusive" | "end_epoch_inclusive" => Ok(GeneratedField::EndEpochInclusive),
4785 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4786 "limit" => Ok(GeneratedField::Limit),
4787 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4788 }
4789 }
4790 }
4791 deserializer.deserialize_identifier(GeneratedVisitor)
4792 }
4793 }
4794 struct GeneratedVisitor;
4795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4796 type Value = GetTableChangeLogsRequest;
4797
4798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4799 formatter.write_str("struct hummock.GetTableChangeLogsRequest")
4800 }
4801
4802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableChangeLogsRequest, V::Error>
4803 where
4804 V: serde::de::MapAccess<'de>,
4805 {
4806 let mut epoch_only__ = None;
4807 let mut exclude_empty__ = None;
4808 let mut start_epoch_inclusive__ = None;
4809 let mut end_epoch_inclusive__ = None;
4810 let mut table_ids__ = None;
4811 let mut limit__ = None;
4812 while let Some(k) = map_.next_key()? {
4813 match k {
4814 GeneratedField::EpochOnly => {
4815 if epoch_only__.is_some() {
4816 return Err(serde::de::Error::duplicate_field("epochOnly"));
4817 }
4818 epoch_only__ = Some(map_.next_value()?);
4819 }
4820 GeneratedField::ExcludeEmpty => {
4821 if exclude_empty__.is_some() {
4822 return Err(serde::de::Error::duplicate_field("excludeEmpty"));
4823 }
4824 exclude_empty__ = Some(map_.next_value()?);
4825 }
4826 GeneratedField::StartEpochInclusive => {
4827 if start_epoch_inclusive__.is_some() {
4828 return Err(serde::de::Error::duplicate_field("startEpochInclusive"));
4829 }
4830 start_epoch_inclusive__ =
4831 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4832 ;
4833 }
4834 GeneratedField::EndEpochInclusive => {
4835 if end_epoch_inclusive__.is_some() {
4836 return Err(serde::de::Error::duplicate_field("endEpochInclusive"));
4837 }
4838 end_epoch_inclusive__ =
4839 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4840 ;
4841 }
4842 GeneratedField::TableIds => {
4843 if table_ids__.is_some() {
4844 return Err(serde::de::Error::duplicate_field("tableIds"));
4845 }
4846 table_ids__ = map_.next_value()?;
4847 }
4848 GeneratedField::Limit => {
4849 if limit__.is_some() {
4850 return Err(serde::de::Error::duplicate_field("limit"));
4851 }
4852 limit__ =
4853 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4854 ;
4855 }
4856 }
4857 }
4858 Ok(GetTableChangeLogsRequest {
4859 epoch_only: epoch_only__.unwrap_or_default(),
4860 exclude_empty: exclude_empty__.unwrap_or_default(),
4861 start_epoch_inclusive: start_epoch_inclusive__,
4862 end_epoch_inclusive: end_epoch_inclusive__,
4863 table_ids: table_ids__,
4864 limit: limit__,
4865 })
4866 }
4867 }
4868 deserializer.deserialize_struct("hummock.GetTableChangeLogsRequest", FIELDS, GeneratedVisitor)
4869 }
4870}
4871impl serde::Serialize for get_table_change_logs_request::TableFilter {
4872 #[allow(deprecated)]
4873 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4874 where
4875 S: serde::Serializer,
4876 {
4877 use serde::ser::SerializeStruct;
4878 let mut len = 0;
4879 if !self.table_ids.is_empty() {
4880 len += 1;
4881 }
4882 let mut struct_ser = serializer.serialize_struct("hummock.GetTableChangeLogsRequest.TableFilter", len)?;
4883 if !self.table_ids.is_empty() {
4884 struct_ser.serialize_field("tableIds", &self.table_ids)?;
4885 }
4886 struct_ser.end()
4887 }
4888}
4889impl<'de> serde::Deserialize<'de> for get_table_change_logs_request::TableFilter {
4890 #[allow(deprecated)]
4891 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4892 where
4893 D: serde::Deserializer<'de>,
4894 {
4895 const FIELDS: &[&str] = &[
4896 "table_ids",
4897 "tableIds",
4898 ];
4899
4900 #[allow(clippy::enum_variant_names)]
4901 enum GeneratedField {
4902 TableIds,
4903 }
4904 impl<'de> serde::Deserialize<'de> for GeneratedField {
4905 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4906 where
4907 D: serde::Deserializer<'de>,
4908 {
4909 struct GeneratedVisitor;
4910
4911 impl serde::de::Visitor<'_> for GeneratedVisitor {
4912 type Value = GeneratedField;
4913
4914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4915 write!(formatter, "expected one of: {:?}", &FIELDS)
4916 }
4917
4918 #[allow(unused_variables)]
4919 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4920 where
4921 E: serde::de::Error,
4922 {
4923 match value {
4924 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4925 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4926 }
4927 }
4928 }
4929 deserializer.deserialize_identifier(GeneratedVisitor)
4930 }
4931 }
4932 struct GeneratedVisitor;
4933 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4934 type Value = get_table_change_logs_request::TableFilter;
4935
4936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4937 formatter.write_str("struct hummock.GetTableChangeLogsRequest.TableFilter")
4938 }
4939
4940 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_table_change_logs_request::TableFilter, V::Error>
4941 where
4942 V: serde::de::MapAccess<'de>,
4943 {
4944 let mut table_ids__ = None;
4945 while let Some(k) = map_.next_key()? {
4946 match k {
4947 GeneratedField::TableIds => {
4948 if table_ids__.is_some() {
4949 return Err(serde::de::Error::duplicate_field("tableIds"));
4950 }
4951 table_ids__ =
4952 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4953 .into_iter().map(|x| x.0).collect())
4954 ;
4955 }
4956 }
4957 }
4958 Ok(get_table_change_logs_request::TableFilter {
4959 table_ids: table_ids__.unwrap_or_default(),
4960 })
4961 }
4962 }
4963 deserializer.deserialize_struct("hummock.GetTableChangeLogsRequest.TableFilter", FIELDS, GeneratedVisitor)
4964 }
4965}
4966impl serde::Serialize for GetTableChangeLogsResponse {
4967 #[allow(deprecated)]
4968 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4969 where
4970 S: serde::Serializer,
4971 {
4972 use serde::ser::SerializeStruct;
4973 let mut len = 0;
4974 if !self.table_change_logs.is_empty() {
4975 len += 1;
4976 }
4977 let mut struct_ser = serializer.serialize_struct("hummock.GetTableChangeLogsResponse", len)?;
4978 if !self.table_change_logs.is_empty() {
4979 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
4980 }
4981 struct_ser.end()
4982 }
4983}
4984impl<'de> serde::Deserialize<'de> for GetTableChangeLogsResponse {
4985 #[allow(deprecated)]
4986 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4987 where
4988 D: serde::Deserializer<'de>,
4989 {
4990 const FIELDS: &[&str] = &[
4991 "table_change_logs",
4992 "tableChangeLogs",
4993 ];
4994
4995 #[allow(clippy::enum_variant_names)]
4996 enum GeneratedField {
4997 TableChangeLogs,
4998 }
4999 impl<'de> serde::Deserialize<'de> for GeneratedField {
5000 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5001 where
5002 D: serde::Deserializer<'de>,
5003 {
5004 struct GeneratedVisitor;
5005
5006 impl serde::de::Visitor<'_> for GeneratedVisitor {
5007 type Value = GeneratedField;
5008
5009 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5010 write!(formatter, "expected one of: {:?}", &FIELDS)
5011 }
5012
5013 #[allow(unused_variables)]
5014 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5015 where
5016 E: serde::de::Error,
5017 {
5018 match value {
5019 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
5020 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5021 }
5022 }
5023 }
5024 deserializer.deserialize_identifier(GeneratedVisitor)
5025 }
5026 }
5027 struct GeneratedVisitor;
5028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5029 type Value = GetTableChangeLogsResponse;
5030
5031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5032 formatter.write_str("struct hummock.GetTableChangeLogsResponse")
5033 }
5034
5035 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableChangeLogsResponse, V::Error>
5036 where
5037 V: serde::de::MapAccess<'de>,
5038 {
5039 let mut table_change_logs__ = None;
5040 while let Some(k) = map_.next_key()? {
5041 match k {
5042 GeneratedField::TableChangeLogs => {
5043 if table_change_logs__.is_some() {
5044 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
5045 }
5046 table_change_logs__ = Some(
5047 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5048 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5049 );
5050 }
5051 }
5052 }
5053 Ok(GetTableChangeLogsResponse {
5054 table_change_logs: table_change_logs__.unwrap_or_default(),
5055 })
5056 }
5057 }
5058 deserializer.deserialize_struct("hummock.GetTableChangeLogsResponse", FIELDS, GeneratedVisitor)
5059 }
5060}
5061impl serde::Serialize for GetVersionByEpochRequest {
5062 #[allow(deprecated)]
5063 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5064 where
5065 S: serde::Serializer,
5066 {
5067 use serde::ser::SerializeStruct;
5068 let mut len = 0;
5069 if self.epoch != 0 {
5070 len += 1;
5071 }
5072 if self.table_id != 0 {
5073 len += 1;
5074 }
5075 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
5076 if self.epoch != 0 {
5077 #[allow(clippy::needless_borrow)]
5078 #[allow(clippy::needless_borrows_for_generic_args)]
5079 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
5080 }
5081 if self.table_id != 0 {
5082 struct_ser.serialize_field("tableId", &self.table_id)?;
5083 }
5084 struct_ser.end()
5085 }
5086}
5087impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
5088 #[allow(deprecated)]
5089 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5090 where
5091 D: serde::Deserializer<'de>,
5092 {
5093 const FIELDS: &[&str] = &[
5094 "epoch",
5095 "table_id",
5096 "tableId",
5097 ];
5098
5099 #[allow(clippy::enum_variant_names)]
5100 enum GeneratedField {
5101 Epoch,
5102 TableId,
5103 }
5104 impl<'de> serde::Deserialize<'de> for GeneratedField {
5105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5106 where
5107 D: serde::Deserializer<'de>,
5108 {
5109 struct GeneratedVisitor;
5110
5111 impl serde::de::Visitor<'_> for GeneratedVisitor {
5112 type Value = GeneratedField;
5113
5114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5115 write!(formatter, "expected one of: {:?}", &FIELDS)
5116 }
5117
5118 #[allow(unused_variables)]
5119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5120 where
5121 E: serde::de::Error,
5122 {
5123 match value {
5124 "epoch" => Ok(GeneratedField::Epoch),
5125 "tableId" | "table_id" => Ok(GeneratedField::TableId),
5126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5127 }
5128 }
5129 }
5130 deserializer.deserialize_identifier(GeneratedVisitor)
5131 }
5132 }
5133 struct GeneratedVisitor;
5134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5135 type Value = GetVersionByEpochRequest;
5136
5137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5138 formatter.write_str("struct hummock.GetVersionByEpochRequest")
5139 }
5140
5141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
5142 where
5143 V: serde::de::MapAccess<'de>,
5144 {
5145 let mut epoch__ = None;
5146 let mut table_id__ = None;
5147 while let Some(k) = map_.next_key()? {
5148 match k {
5149 GeneratedField::Epoch => {
5150 if epoch__.is_some() {
5151 return Err(serde::de::Error::duplicate_field("epoch"));
5152 }
5153 epoch__ =
5154 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5155 ;
5156 }
5157 GeneratedField::TableId => {
5158 if table_id__.is_some() {
5159 return Err(serde::de::Error::duplicate_field("tableId"));
5160 }
5161 table_id__ =
5162 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5163 ;
5164 }
5165 }
5166 }
5167 Ok(GetVersionByEpochRequest {
5168 epoch: epoch__.unwrap_or_default(),
5169 table_id: table_id__.unwrap_or_default(),
5170 })
5171 }
5172 }
5173 deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
5174 }
5175}
5176impl serde::Serialize for GetVersionByEpochResponse {
5177 #[allow(deprecated)]
5178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5179 where
5180 S: serde::Serializer,
5181 {
5182 use serde::ser::SerializeStruct;
5183 let mut len = 0;
5184 if self.version.is_some() {
5185 len += 1;
5186 }
5187 let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
5188 if let Some(v) = self.version.as_ref() {
5189 struct_ser.serialize_field("version", v)?;
5190 }
5191 struct_ser.end()
5192 }
5193}
5194impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
5195 #[allow(deprecated)]
5196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5197 where
5198 D: serde::Deserializer<'de>,
5199 {
5200 const FIELDS: &[&str] = &[
5201 "version",
5202 ];
5203
5204 #[allow(clippy::enum_variant_names)]
5205 enum GeneratedField {
5206 Version,
5207 }
5208 impl<'de> serde::Deserialize<'de> for GeneratedField {
5209 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5210 where
5211 D: serde::Deserializer<'de>,
5212 {
5213 struct GeneratedVisitor;
5214
5215 impl serde::de::Visitor<'_> for GeneratedVisitor {
5216 type Value = GeneratedField;
5217
5218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5219 write!(formatter, "expected one of: {:?}", &FIELDS)
5220 }
5221
5222 #[allow(unused_variables)]
5223 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5224 where
5225 E: serde::de::Error,
5226 {
5227 match value {
5228 "version" => Ok(GeneratedField::Version),
5229 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5230 }
5231 }
5232 }
5233 deserializer.deserialize_identifier(GeneratedVisitor)
5234 }
5235 }
5236 struct GeneratedVisitor;
5237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5238 type Value = GetVersionByEpochResponse;
5239
5240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5241 formatter.write_str("struct hummock.GetVersionByEpochResponse")
5242 }
5243
5244 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
5245 where
5246 V: serde::de::MapAccess<'de>,
5247 {
5248 let mut version__ = None;
5249 while let Some(k) = map_.next_key()? {
5250 match k {
5251 GeneratedField::Version => {
5252 if version__.is_some() {
5253 return Err(serde::de::Error::duplicate_field("version"));
5254 }
5255 version__ = map_.next_value()?;
5256 }
5257 }
5258 }
5259 Ok(GetVersionByEpochResponse {
5260 version: version__,
5261 })
5262 }
5263 }
5264 deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
5265 }
5266}
5267impl serde::Serialize for GroupConstruct {
5268 #[allow(deprecated)]
5269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5270 where
5271 S: serde::Serializer,
5272 {
5273 use serde::ser::SerializeStruct;
5274 let mut len = 0;
5275 if self.group_config.is_some() {
5276 len += 1;
5277 }
5278 if self.parent_group_id != 0 {
5279 len += 1;
5280 }
5281 if !self.table_ids.is_empty() {
5282 len += 1;
5283 }
5284 if self.group_id != 0 {
5285 len += 1;
5286 }
5287 if self.new_sst_start_id != 0 {
5288 len += 1;
5289 }
5290 if self.version != 0 {
5291 len += 1;
5292 }
5293 if self.split_key.is_some() {
5294 len += 1;
5295 }
5296 let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
5297 if let Some(v) = self.group_config.as_ref() {
5298 struct_ser.serialize_field("groupConfig", v)?;
5299 }
5300 if self.parent_group_id != 0 {
5301 #[allow(clippy::needless_borrow)]
5302 #[allow(clippy::needless_borrows_for_generic_args)]
5303 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
5304 }
5305 if !self.table_ids.is_empty() {
5306 struct_ser.serialize_field("tableIds", &self.table_ids)?;
5307 }
5308 if self.group_id != 0 {
5309 #[allow(clippy::needless_borrow)]
5310 #[allow(clippy::needless_borrows_for_generic_args)]
5311 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
5312 }
5313 if self.new_sst_start_id != 0 {
5314 #[allow(clippy::needless_borrow)]
5315 #[allow(clippy::needless_borrows_for_generic_args)]
5316 struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
5317 }
5318 if self.version != 0 {
5319 let v = CompatibilityVersion::try_from(self.version)
5320 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5321 struct_ser.serialize_field("version", &v)?;
5322 }
5323 if let Some(v) = self.split_key.as_ref() {
5324 #[allow(clippy::needless_borrow)]
5325 #[allow(clippy::needless_borrows_for_generic_args)]
5326 struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
5327 }
5328 struct_ser.end()
5329 }
5330}
5331impl<'de> serde::Deserialize<'de> for GroupConstruct {
5332 #[allow(deprecated)]
5333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5334 where
5335 D: serde::Deserializer<'de>,
5336 {
5337 const FIELDS: &[&str] = &[
5338 "group_config",
5339 "groupConfig",
5340 "parent_group_id",
5341 "parentGroupId",
5342 "table_ids",
5343 "tableIds",
5344 "group_id",
5345 "groupId",
5346 "new_sst_start_id",
5347 "newSstStartId",
5348 "version",
5349 "split_key",
5350 "splitKey",
5351 ];
5352
5353 #[allow(clippy::enum_variant_names)]
5354 enum GeneratedField {
5355 GroupConfig,
5356 ParentGroupId,
5357 TableIds,
5358 GroupId,
5359 NewSstStartId,
5360 Version,
5361 SplitKey,
5362 }
5363 impl<'de> serde::Deserialize<'de> for GeneratedField {
5364 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5365 where
5366 D: serde::Deserializer<'de>,
5367 {
5368 struct GeneratedVisitor;
5369
5370 impl serde::de::Visitor<'_> for GeneratedVisitor {
5371 type Value = GeneratedField;
5372
5373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5374 write!(formatter, "expected one of: {:?}", &FIELDS)
5375 }
5376
5377 #[allow(unused_variables)]
5378 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5379 where
5380 E: serde::de::Error,
5381 {
5382 match value {
5383 "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
5384 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
5385 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
5386 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
5387 "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
5388 "version" => Ok(GeneratedField::Version),
5389 "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
5390 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5391 }
5392 }
5393 }
5394 deserializer.deserialize_identifier(GeneratedVisitor)
5395 }
5396 }
5397 struct GeneratedVisitor;
5398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5399 type Value = GroupConstruct;
5400
5401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5402 formatter.write_str("struct hummock.GroupConstruct")
5403 }
5404
5405 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
5406 where
5407 V: serde::de::MapAccess<'de>,
5408 {
5409 let mut group_config__ = None;
5410 let mut parent_group_id__ = None;
5411 let mut table_ids__ = None;
5412 let mut group_id__ = None;
5413 let mut new_sst_start_id__ = None;
5414 let mut version__ = None;
5415 let mut split_key__ = None;
5416 while let Some(k) = map_.next_key()? {
5417 match k {
5418 GeneratedField::GroupConfig => {
5419 if group_config__.is_some() {
5420 return Err(serde::de::Error::duplicate_field("groupConfig"));
5421 }
5422 group_config__ = map_.next_value()?;
5423 }
5424 GeneratedField::ParentGroupId => {
5425 if parent_group_id__.is_some() {
5426 return Err(serde::de::Error::duplicate_field("parentGroupId"));
5427 }
5428 parent_group_id__ =
5429 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5430 ;
5431 }
5432 GeneratedField::TableIds => {
5433 if table_ids__.is_some() {
5434 return Err(serde::de::Error::duplicate_field("tableIds"));
5435 }
5436 table_ids__ =
5437 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5438 .into_iter().map(|x| x.0).collect())
5439 ;
5440 }
5441 GeneratedField::GroupId => {
5442 if group_id__.is_some() {
5443 return Err(serde::de::Error::duplicate_field("groupId"));
5444 }
5445 group_id__ =
5446 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5447 ;
5448 }
5449 GeneratedField::NewSstStartId => {
5450 if new_sst_start_id__.is_some() {
5451 return Err(serde::de::Error::duplicate_field("newSstStartId"));
5452 }
5453 new_sst_start_id__ =
5454 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5455 ;
5456 }
5457 GeneratedField::Version => {
5458 if version__.is_some() {
5459 return Err(serde::de::Error::duplicate_field("version"));
5460 }
5461 version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
5462 }
5463 GeneratedField::SplitKey => {
5464 if split_key__.is_some() {
5465 return Err(serde::de::Error::duplicate_field("splitKey"));
5466 }
5467 split_key__ =
5468 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
5469 ;
5470 }
5471 }
5472 }
5473 Ok(GroupConstruct {
5474 group_config: group_config__,
5475 parent_group_id: parent_group_id__.unwrap_or_default(),
5476 table_ids: table_ids__.unwrap_or_default(),
5477 group_id: group_id__.unwrap_or_default(),
5478 new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
5479 version: version__.unwrap_or_default(),
5480 split_key: split_key__,
5481 })
5482 }
5483 }
5484 deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
5485 }
5486}
5487impl serde::Serialize for GroupDelta {
5488 #[allow(deprecated)]
5489 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5490 where
5491 S: serde::Serializer,
5492 {
5493 use serde::ser::SerializeStruct;
5494 let mut len = 0;
5495 if self.delta_type.is_some() {
5496 len += 1;
5497 }
5498 let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
5499 if let Some(v) = self.delta_type.as_ref() {
5500 match v {
5501 group_delta::DeltaType::IntraLevel(v) => {
5502 struct_ser.serialize_field("intraLevel", v)?;
5503 }
5504 group_delta::DeltaType::GroupConstruct(v) => {
5505 struct_ser.serialize_field("groupConstruct", v)?;
5506 }
5507 group_delta::DeltaType::GroupDestroy(v) => {
5508 struct_ser.serialize_field("groupDestroy", v)?;
5509 }
5510 group_delta::DeltaType::GroupMerge(v) => {
5511 struct_ser.serialize_field("groupMerge", v)?;
5512 }
5513 group_delta::DeltaType::NewL0SubLevel(v) => {
5514 struct_ser.serialize_field("newL0SubLevel", v)?;
5515 }
5516 group_delta::DeltaType::TruncateTables(v) => {
5517 struct_ser.serialize_field("truncateTables", v)?;
5518 }
5519 }
5520 }
5521 struct_ser.end()
5522 }
5523}
5524impl<'de> serde::Deserialize<'de> for GroupDelta {
5525 #[allow(deprecated)]
5526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5527 where
5528 D: serde::Deserializer<'de>,
5529 {
5530 const FIELDS: &[&str] = &[
5531 "intra_level",
5532 "intraLevel",
5533 "group_construct",
5534 "groupConstruct",
5535 "group_destroy",
5536 "groupDestroy",
5537 "group_merge",
5538 "groupMerge",
5539 "new_l0_sub_level",
5540 "newL0SubLevel",
5541 "truncate_tables",
5542 "truncateTables",
5543 ];
5544
5545 #[allow(clippy::enum_variant_names)]
5546 enum GeneratedField {
5547 IntraLevel,
5548 GroupConstruct,
5549 GroupDestroy,
5550 GroupMerge,
5551 NewL0SubLevel,
5552 TruncateTables,
5553 }
5554 impl<'de> serde::Deserialize<'de> for GeneratedField {
5555 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5556 where
5557 D: serde::Deserializer<'de>,
5558 {
5559 struct GeneratedVisitor;
5560
5561 impl serde::de::Visitor<'_> for GeneratedVisitor {
5562 type Value = GeneratedField;
5563
5564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5565 write!(formatter, "expected one of: {:?}", &FIELDS)
5566 }
5567
5568 #[allow(unused_variables)]
5569 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5570 where
5571 E: serde::de::Error,
5572 {
5573 match value {
5574 "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5575 "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5576 "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5577 "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5578 "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5579 "truncateTables" | "truncate_tables" => Ok(GeneratedField::TruncateTables),
5580 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5581 }
5582 }
5583 }
5584 deserializer.deserialize_identifier(GeneratedVisitor)
5585 }
5586 }
5587 struct GeneratedVisitor;
5588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5589 type Value = GroupDelta;
5590
5591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5592 formatter.write_str("struct hummock.GroupDelta")
5593 }
5594
5595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5596 where
5597 V: serde::de::MapAccess<'de>,
5598 {
5599 let mut delta_type__ = None;
5600 while let Some(k) = map_.next_key()? {
5601 match k {
5602 GeneratedField::IntraLevel => {
5603 if delta_type__.is_some() {
5604 return Err(serde::de::Error::duplicate_field("intraLevel"));
5605 }
5606 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5607;
5608 }
5609 GeneratedField::GroupConstruct => {
5610 if delta_type__.is_some() {
5611 return Err(serde::de::Error::duplicate_field("groupConstruct"));
5612 }
5613 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5614;
5615 }
5616 GeneratedField::GroupDestroy => {
5617 if delta_type__.is_some() {
5618 return Err(serde::de::Error::duplicate_field("groupDestroy"));
5619 }
5620 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5621;
5622 }
5623 GeneratedField::GroupMerge => {
5624 if delta_type__.is_some() {
5625 return Err(serde::de::Error::duplicate_field("groupMerge"));
5626 }
5627 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5628;
5629 }
5630 GeneratedField::NewL0SubLevel => {
5631 if delta_type__.is_some() {
5632 return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5633 }
5634 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5635;
5636 }
5637 GeneratedField::TruncateTables => {
5638 if delta_type__.is_some() {
5639 return Err(serde::de::Error::duplicate_field("truncateTables"));
5640 }
5641 delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::TruncateTables)
5642;
5643 }
5644 }
5645 }
5646 Ok(GroupDelta {
5647 delta_type: delta_type__,
5648 })
5649 }
5650 }
5651 deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5652 }
5653}
5654impl serde::Serialize for GroupDestroy {
5655 #[allow(deprecated)]
5656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5657 where
5658 S: serde::Serializer,
5659 {
5660 use serde::ser::SerializeStruct;
5661 let len = 0;
5662 let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5663 struct_ser.end()
5664 }
5665}
5666impl<'de> serde::Deserialize<'de> for GroupDestroy {
5667 #[allow(deprecated)]
5668 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5669 where
5670 D: serde::Deserializer<'de>,
5671 {
5672 const FIELDS: &[&str] = &[
5673 ];
5674
5675 #[allow(clippy::enum_variant_names)]
5676 enum GeneratedField {
5677 }
5678 impl<'de> serde::Deserialize<'de> for GeneratedField {
5679 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5680 where
5681 D: serde::Deserializer<'de>,
5682 {
5683 struct GeneratedVisitor;
5684
5685 impl serde::de::Visitor<'_> for GeneratedVisitor {
5686 type Value = GeneratedField;
5687
5688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5689 write!(formatter, "expected one of: {:?}", &FIELDS)
5690 }
5691
5692 #[allow(unused_variables)]
5693 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5694 where
5695 E: serde::de::Error,
5696 {
5697 Err(serde::de::Error::unknown_field(value, FIELDS))
5698 }
5699 }
5700 deserializer.deserialize_identifier(GeneratedVisitor)
5701 }
5702 }
5703 struct GeneratedVisitor;
5704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5705 type Value = GroupDestroy;
5706
5707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5708 formatter.write_str("struct hummock.GroupDestroy")
5709 }
5710
5711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5712 where
5713 V: serde::de::MapAccess<'de>,
5714 {
5715 while map_.next_key::<GeneratedField>()?.is_some() {
5716 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5717 }
5718 Ok(GroupDestroy {
5719 })
5720 }
5721 }
5722 deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5723 }
5724}
5725impl serde::Serialize for GroupMerge {
5726 #[allow(deprecated)]
5727 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5728 where
5729 S: serde::Serializer,
5730 {
5731 use serde::ser::SerializeStruct;
5732 let mut len = 0;
5733 if self.left_group_id != 0 {
5734 len += 1;
5735 }
5736 if self.right_group_id != 0 {
5737 len += 1;
5738 }
5739 let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5740 if self.left_group_id != 0 {
5741 #[allow(clippy::needless_borrow)]
5742 #[allow(clippy::needless_borrows_for_generic_args)]
5743 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5744 }
5745 if self.right_group_id != 0 {
5746 #[allow(clippy::needless_borrow)]
5747 #[allow(clippy::needless_borrows_for_generic_args)]
5748 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5749 }
5750 struct_ser.end()
5751 }
5752}
5753impl<'de> serde::Deserialize<'de> for GroupMerge {
5754 #[allow(deprecated)]
5755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5756 where
5757 D: serde::Deserializer<'de>,
5758 {
5759 const FIELDS: &[&str] = &[
5760 "left_group_id",
5761 "leftGroupId",
5762 "right_group_id",
5763 "rightGroupId",
5764 ];
5765
5766 #[allow(clippy::enum_variant_names)]
5767 enum GeneratedField {
5768 LeftGroupId,
5769 RightGroupId,
5770 }
5771 impl<'de> serde::Deserialize<'de> for GeneratedField {
5772 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5773 where
5774 D: serde::Deserializer<'de>,
5775 {
5776 struct GeneratedVisitor;
5777
5778 impl serde::de::Visitor<'_> for GeneratedVisitor {
5779 type Value = GeneratedField;
5780
5781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5782 write!(formatter, "expected one of: {:?}", &FIELDS)
5783 }
5784
5785 #[allow(unused_variables)]
5786 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5787 where
5788 E: serde::de::Error,
5789 {
5790 match value {
5791 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5792 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5793 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5794 }
5795 }
5796 }
5797 deserializer.deserialize_identifier(GeneratedVisitor)
5798 }
5799 }
5800 struct GeneratedVisitor;
5801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5802 type Value = GroupMerge;
5803
5804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5805 formatter.write_str("struct hummock.GroupMerge")
5806 }
5807
5808 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5809 where
5810 V: serde::de::MapAccess<'de>,
5811 {
5812 let mut left_group_id__ = None;
5813 let mut right_group_id__ = None;
5814 while let Some(k) = map_.next_key()? {
5815 match k {
5816 GeneratedField::LeftGroupId => {
5817 if left_group_id__.is_some() {
5818 return Err(serde::de::Error::duplicate_field("leftGroupId"));
5819 }
5820 left_group_id__ =
5821 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5822 ;
5823 }
5824 GeneratedField::RightGroupId => {
5825 if right_group_id__.is_some() {
5826 return Err(serde::de::Error::duplicate_field("rightGroupId"));
5827 }
5828 right_group_id__ =
5829 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5830 ;
5831 }
5832 }
5833 }
5834 Ok(GroupMerge {
5835 left_group_id: left_group_id__.unwrap_or_default(),
5836 right_group_id: right_group_id__.unwrap_or_default(),
5837 })
5838 }
5839 }
5840 deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5841 }
5842}
5843impl serde::Serialize for HnswFlatIndex {
5844 #[allow(deprecated)]
5845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5846 where
5847 S: serde::Serializer,
5848 {
5849 use serde::ser::SerializeStruct;
5850 let mut len = 0;
5851 if self.config.is_some() {
5852 len += 1;
5853 }
5854 if !self.vector_files.is_empty() {
5855 len += 1;
5856 }
5857 if self.next_vector_id != 0 {
5858 len += 1;
5859 }
5860 if self.graph_file.is_some() {
5861 len += 1;
5862 }
5863 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndex", len)?;
5864 if let Some(v) = self.config.as_ref() {
5865 struct_ser.serialize_field("config", v)?;
5866 }
5867 if !self.vector_files.is_empty() {
5868 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
5869 }
5870 if self.next_vector_id != 0 {
5871 #[allow(clippy::needless_borrow)]
5872 #[allow(clippy::needless_borrows_for_generic_args)]
5873 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5874 }
5875 if let Some(v) = self.graph_file.as_ref() {
5876 struct_ser.serialize_field("graphFile", v)?;
5877 }
5878 struct_ser.end()
5879 }
5880}
5881impl<'de> serde::Deserialize<'de> for HnswFlatIndex {
5882 #[allow(deprecated)]
5883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5884 where
5885 D: serde::Deserializer<'de>,
5886 {
5887 const FIELDS: &[&str] = &[
5888 "config",
5889 "vector_files",
5890 "vectorFiles",
5891 "next_vector_id",
5892 "nextVectorId",
5893 "graph_file",
5894 "graphFile",
5895 ];
5896
5897 #[allow(clippy::enum_variant_names)]
5898 enum GeneratedField {
5899 Config,
5900 VectorFiles,
5901 NextVectorId,
5902 GraphFile,
5903 }
5904 impl<'de> serde::Deserialize<'de> for GeneratedField {
5905 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5906 where
5907 D: serde::Deserializer<'de>,
5908 {
5909 struct GeneratedVisitor;
5910
5911 impl serde::de::Visitor<'_> for GeneratedVisitor {
5912 type Value = GeneratedField;
5913
5914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5915 write!(formatter, "expected one of: {:?}", &FIELDS)
5916 }
5917
5918 #[allow(unused_variables)]
5919 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5920 where
5921 E: serde::de::Error,
5922 {
5923 match value {
5924 "config" => Ok(GeneratedField::Config),
5925 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
5926 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
5927 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
5928 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5929 }
5930 }
5931 }
5932 deserializer.deserialize_identifier(GeneratedVisitor)
5933 }
5934 }
5935 struct GeneratedVisitor;
5936 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5937 type Value = HnswFlatIndex;
5938
5939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5940 formatter.write_str("struct hummock.HnswFlatIndex")
5941 }
5942
5943 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndex, V::Error>
5944 where
5945 V: serde::de::MapAccess<'de>,
5946 {
5947 let mut config__ = None;
5948 let mut vector_files__ = None;
5949 let mut next_vector_id__ = None;
5950 let mut graph_file__ = None;
5951 while let Some(k) = map_.next_key()? {
5952 match k {
5953 GeneratedField::Config => {
5954 if config__.is_some() {
5955 return Err(serde::de::Error::duplicate_field("config"));
5956 }
5957 config__ = map_.next_value()?;
5958 }
5959 GeneratedField::VectorFiles => {
5960 if vector_files__.is_some() {
5961 return Err(serde::de::Error::duplicate_field("vectorFiles"));
5962 }
5963 vector_files__ = Some(map_.next_value()?);
5964 }
5965 GeneratedField::NextVectorId => {
5966 if next_vector_id__.is_some() {
5967 return Err(serde::de::Error::duplicate_field("nextVectorId"));
5968 }
5969 next_vector_id__ =
5970 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5971 ;
5972 }
5973 GeneratedField::GraphFile => {
5974 if graph_file__.is_some() {
5975 return Err(serde::de::Error::duplicate_field("graphFile"));
5976 }
5977 graph_file__ = map_.next_value()?;
5978 }
5979 }
5980 }
5981 Ok(HnswFlatIndex {
5982 config: config__,
5983 vector_files: vector_files__.unwrap_or_default(),
5984 next_vector_id: next_vector_id__.unwrap_or_default(),
5985 graph_file: graph_file__,
5986 })
5987 }
5988 }
5989 deserializer.deserialize_struct("hummock.HnswFlatIndex", FIELDS, GeneratedVisitor)
5990 }
5991}
5992impl serde::Serialize for HnswFlatIndexAdd {
5993 #[allow(deprecated)]
5994 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5995 where
5996 S: serde::Serializer,
5997 {
5998 use serde::ser::SerializeStruct;
5999 let mut len = 0;
6000 if !self.added_vector_files.is_empty() {
6001 len += 1;
6002 }
6003 if self.next_vector_id != 0 {
6004 len += 1;
6005 }
6006 if self.graph_file.is_some() {
6007 len += 1;
6008 }
6009 let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndexAdd", len)?;
6010 if !self.added_vector_files.is_empty() {
6011 struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
6012 }
6013 if self.next_vector_id != 0 {
6014 #[allow(clippy::needless_borrow)]
6015 #[allow(clippy::needless_borrows_for_generic_args)]
6016 struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
6017 }
6018 if let Some(v) = self.graph_file.as_ref() {
6019 struct_ser.serialize_field("graphFile", v)?;
6020 }
6021 struct_ser.end()
6022 }
6023}
6024impl<'de> serde::Deserialize<'de> for HnswFlatIndexAdd {
6025 #[allow(deprecated)]
6026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6027 where
6028 D: serde::Deserializer<'de>,
6029 {
6030 const FIELDS: &[&str] = &[
6031 "added_vector_files",
6032 "addedVectorFiles",
6033 "next_vector_id",
6034 "nextVectorId",
6035 "graph_file",
6036 "graphFile",
6037 ];
6038
6039 #[allow(clippy::enum_variant_names)]
6040 enum GeneratedField {
6041 AddedVectorFiles,
6042 NextVectorId,
6043 GraphFile,
6044 }
6045 impl<'de> serde::Deserialize<'de> for GeneratedField {
6046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6047 where
6048 D: serde::Deserializer<'de>,
6049 {
6050 struct GeneratedVisitor;
6051
6052 impl serde::de::Visitor<'_> for GeneratedVisitor {
6053 type Value = GeneratedField;
6054
6055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6056 write!(formatter, "expected one of: {:?}", &FIELDS)
6057 }
6058
6059 #[allow(unused_variables)]
6060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6061 where
6062 E: serde::de::Error,
6063 {
6064 match value {
6065 "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
6066 "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
6067 "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
6068 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6069 }
6070 }
6071 }
6072 deserializer.deserialize_identifier(GeneratedVisitor)
6073 }
6074 }
6075 struct GeneratedVisitor;
6076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6077 type Value = HnswFlatIndexAdd;
6078
6079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6080 formatter.write_str("struct hummock.HnswFlatIndexAdd")
6081 }
6082
6083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndexAdd, V::Error>
6084 where
6085 V: serde::de::MapAccess<'de>,
6086 {
6087 let mut added_vector_files__ = None;
6088 let mut next_vector_id__ = None;
6089 let mut graph_file__ = None;
6090 while let Some(k) = map_.next_key()? {
6091 match k {
6092 GeneratedField::AddedVectorFiles => {
6093 if added_vector_files__.is_some() {
6094 return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
6095 }
6096 added_vector_files__ = Some(map_.next_value()?);
6097 }
6098 GeneratedField::NextVectorId => {
6099 if next_vector_id__.is_some() {
6100 return Err(serde::de::Error::duplicate_field("nextVectorId"));
6101 }
6102 next_vector_id__ =
6103 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6104 ;
6105 }
6106 GeneratedField::GraphFile => {
6107 if graph_file__.is_some() {
6108 return Err(serde::de::Error::duplicate_field("graphFile"));
6109 }
6110 graph_file__ = map_.next_value()?;
6111 }
6112 }
6113 }
6114 Ok(HnswFlatIndexAdd {
6115 added_vector_files: added_vector_files__.unwrap_or_default(),
6116 next_vector_id: next_vector_id__.unwrap_or_default(),
6117 graph_file: graph_file__,
6118 })
6119 }
6120 }
6121 deserializer.deserialize_struct("hummock.HnswFlatIndexAdd", FIELDS, GeneratedVisitor)
6122 }
6123}
6124impl serde::Serialize for HnswGraph {
6125 #[allow(deprecated)]
6126 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6127 where
6128 S: serde::Serializer,
6129 {
6130 use serde::ser::SerializeStruct;
6131 let mut len = 0;
6132 if !self.nodes.is_empty() {
6133 len += 1;
6134 }
6135 if self.entrypoint_id != 0 {
6136 len += 1;
6137 }
6138 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph", len)?;
6139 if !self.nodes.is_empty() {
6140 struct_ser.serialize_field("nodes", &self.nodes)?;
6141 }
6142 if self.entrypoint_id != 0 {
6143 #[allow(clippy::needless_borrow)]
6144 #[allow(clippy::needless_borrows_for_generic_args)]
6145 struct_ser.serialize_field("entrypointId", ToString::to_string(&self.entrypoint_id).as_str())?;
6146 }
6147 struct_ser.end()
6148 }
6149}
6150impl<'de> serde::Deserialize<'de> for HnswGraph {
6151 #[allow(deprecated)]
6152 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6153 where
6154 D: serde::Deserializer<'de>,
6155 {
6156 const FIELDS: &[&str] = &[
6157 "nodes",
6158 "entrypoint_id",
6159 "entrypointId",
6160 ];
6161
6162 #[allow(clippy::enum_variant_names)]
6163 enum GeneratedField {
6164 Nodes,
6165 EntrypointId,
6166 }
6167 impl<'de> serde::Deserialize<'de> for GeneratedField {
6168 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6169 where
6170 D: serde::Deserializer<'de>,
6171 {
6172 struct GeneratedVisitor;
6173
6174 impl serde::de::Visitor<'_> for GeneratedVisitor {
6175 type Value = GeneratedField;
6176
6177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6178 write!(formatter, "expected one of: {:?}", &FIELDS)
6179 }
6180
6181 #[allow(unused_variables)]
6182 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6183 where
6184 E: serde::de::Error,
6185 {
6186 match value {
6187 "nodes" => Ok(GeneratedField::Nodes),
6188 "entrypointId" | "entrypoint_id" => Ok(GeneratedField::EntrypointId),
6189 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6190 }
6191 }
6192 }
6193 deserializer.deserialize_identifier(GeneratedVisitor)
6194 }
6195 }
6196 struct GeneratedVisitor;
6197 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6198 type Value = HnswGraph;
6199
6200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6201 formatter.write_str("struct hummock.HnswGraph")
6202 }
6203
6204 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraph, V::Error>
6205 where
6206 V: serde::de::MapAccess<'de>,
6207 {
6208 let mut nodes__ = None;
6209 let mut entrypoint_id__ = None;
6210 while let Some(k) = map_.next_key()? {
6211 match k {
6212 GeneratedField::Nodes => {
6213 if nodes__.is_some() {
6214 return Err(serde::de::Error::duplicate_field("nodes"));
6215 }
6216 nodes__ = Some(map_.next_value()?);
6217 }
6218 GeneratedField::EntrypointId => {
6219 if entrypoint_id__.is_some() {
6220 return Err(serde::de::Error::duplicate_field("entrypointId"));
6221 }
6222 entrypoint_id__ =
6223 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6224 ;
6225 }
6226 }
6227 }
6228 Ok(HnswGraph {
6229 nodes: nodes__.unwrap_or_default(),
6230 entrypoint_id: entrypoint_id__.unwrap_or_default(),
6231 })
6232 }
6233 }
6234 deserializer.deserialize_struct("hummock.HnswGraph", FIELDS, GeneratedVisitor)
6235 }
6236}
6237impl serde::Serialize for hnsw_graph::HnswLevel {
6238 #[allow(deprecated)]
6239 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6240 where
6241 S: serde::Serializer,
6242 {
6243 use serde::ser::SerializeStruct;
6244 let mut len = 0;
6245 if !self.neighbors.is_empty() {
6246 len += 1;
6247 }
6248 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswLevel", len)?;
6249 if !self.neighbors.is_empty() {
6250 struct_ser.serialize_field("neighbors", &self.neighbors)?;
6251 }
6252 struct_ser.end()
6253 }
6254}
6255impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswLevel {
6256 #[allow(deprecated)]
6257 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6258 where
6259 D: serde::Deserializer<'de>,
6260 {
6261 const FIELDS: &[&str] = &[
6262 "neighbors",
6263 ];
6264
6265 #[allow(clippy::enum_variant_names)]
6266 enum GeneratedField {
6267 Neighbors,
6268 }
6269 impl<'de> serde::Deserialize<'de> for GeneratedField {
6270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6271 where
6272 D: serde::Deserializer<'de>,
6273 {
6274 struct GeneratedVisitor;
6275
6276 impl serde::de::Visitor<'_> for GeneratedVisitor {
6277 type Value = GeneratedField;
6278
6279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6280 write!(formatter, "expected one of: {:?}", &FIELDS)
6281 }
6282
6283 #[allow(unused_variables)]
6284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6285 where
6286 E: serde::de::Error,
6287 {
6288 match value {
6289 "neighbors" => Ok(GeneratedField::Neighbors),
6290 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6291 }
6292 }
6293 }
6294 deserializer.deserialize_identifier(GeneratedVisitor)
6295 }
6296 }
6297 struct GeneratedVisitor;
6298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6299 type Value = hnsw_graph::HnswLevel;
6300
6301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6302 formatter.write_str("struct hummock.HnswGraph.HnswLevel")
6303 }
6304
6305 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswLevel, V::Error>
6306 where
6307 V: serde::de::MapAccess<'de>,
6308 {
6309 let mut neighbors__ = None;
6310 while let Some(k) = map_.next_key()? {
6311 match k {
6312 GeneratedField::Neighbors => {
6313 if neighbors__.is_some() {
6314 return Err(serde::de::Error::duplicate_field("neighbors"));
6315 }
6316 neighbors__ = Some(map_.next_value()?);
6317 }
6318 }
6319 }
6320 Ok(hnsw_graph::HnswLevel {
6321 neighbors: neighbors__.unwrap_or_default(),
6322 })
6323 }
6324 }
6325 deserializer.deserialize_struct("hummock.HnswGraph.HnswLevel", FIELDS, GeneratedVisitor)
6326 }
6327}
6328impl serde::Serialize for hnsw_graph::HnswNeighbor {
6329 #[allow(deprecated)]
6330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6331 where
6332 S: serde::Serializer,
6333 {
6334 use serde::ser::SerializeStruct;
6335 let mut len = 0;
6336 if self.vector_id != 0 {
6337 len += 1;
6338 }
6339 if self.distance != 0. {
6340 len += 1;
6341 }
6342 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNeighbor", len)?;
6343 if self.vector_id != 0 {
6344 #[allow(clippy::needless_borrow)]
6345 #[allow(clippy::needless_borrows_for_generic_args)]
6346 struct_ser.serialize_field("vectorId", ToString::to_string(&self.vector_id).as_str())?;
6347 }
6348 if self.distance != 0. {
6349 struct_ser.serialize_field("distance", &self.distance)?;
6350 }
6351 struct_ser.end()
6352 }
6353}
6354impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNeighbor {
6355 #[allow(deprecated)]
6356 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6357 where
6358 D: serde::Deserializer<'de>,
6359 {
6360 const FIELDS: &[&str] = &[
6361 "vector_id",
6362 "vectorId",
6363 "distance",
6364 ];
6365
6366 #[allow(clippy::enum_variant_names)]
6367 enum GeneratedField {
6368 VectorId,
6369 Distance,
6370 }
6371 impl<'de> serde::Deserialize<'de> for GeneratedField {
6372 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6373 where
6374 D: serde::Deserializer<'de>,
6375 {
6376 struct GeneratedVisitor;
6377
6378 impl serde::de::Visitor<'_> for GeneratedVisitor {
6379 type Value = GeneratedField;
6380
6381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6382 write!(formatter, "expected one of: {:?}", &FIELDS)
6383 }
6384
6385 #[allow(unused_variables)]
6386 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6387 where
6388 E: serde::de::Error,
6389 {
6390 match value {
6391 "vectorId" | "vector_id" => Ok(GeneratedField::VectorId),
6392 "distance" => Ok(GeneratedField::Distance),
6393 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6394 }
6395 }
6396 }
6397 deserializer.deserialize_identifier(GeneratedVisitor)
6398 }
6399 }
6400 struct GeneratedVisitor;
6401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6402 type Value = hnsw_graph::HnswNeighbor;
6403
6404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6405 formatter.write_str("struct hummock.HnswGraph.HnswNeighbor")
6406 }
6407
6408 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNeighbor, V::Error>
6409 where
6410 V: serde::de::MapAccess<'de>,
6411 {
6412 let mut vector_id__ = None;
6413 let mut distance__ = None;
6414 while let Some(k) = map_.next_key()? {
6415 match k {
6416 GeneratedField::VectorId => {
6417 if vector_id__.is_some() {
6418 return Err(serde::de::Error::duplicate_field("vectorId"));
6419 }
6420 vector_id__ =
6421 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6422 ;
6423 }
6424 GeneratedField::Distance => {
6425 if distance__.is_some() {
6426 return Err(serde::de::Error::duplicate_field("distance"));
6427 }
6428 distance__ =
6429 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6430 ;
6431 }
6432 }
6433 }
6434 Ok(hnsw_graph::HnswNeighbor {
6435 vector_id: vector_id__.unwrap_or_default(),
6436 distance: distance__.unwrap_or_default(),
6437 })
6438 }
6439 }
6440 deserializer.deserialize_struct("hummock.HnswGraph.HnswNeighbor", FIELDS, GeneratedVisitor)
6441 }
6442}
6443impl serde::Serialize for hnsw_graph::HnswNode {
6444 #[allow(deprecated)]
6445 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6446 where
6447 S: serde::Serializer,
6448 {
6449 use serde::ser::SerializeStruct;
6450 let mut len = 0;
6451 if !self.levels.is_empty() {
6452 len += 1;
6453 }
6454 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNode", len)?;
6455 if !self.levels.is_empty() {
6456 struct_ser.serialize_field("levels", &self.levels)?;
6457 }
6458 struct_ser.end()
6459 }
6460}
6461impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNode {
6462 #[allow(deprecated)]
6463 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6464 where
6465 D: serde::Deserializer<'de>,
6466 {
6467 const FIELDS: &[&str] = &[
6468 "levels",
6469 ];
6470
6471 #[allow(clippy::enum_variant_names)]
6472 enum GeneratedField {
6473 Levels,
6474 }
6475 impl<'de> serde::Deserialize<'de> for GeneratedField {
6476 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6477 where
6478 D: serde::Deserializer<'de>,
6479 {
6480 struct GeneratedVisitor;
6481
6482 impl serde::de::Visitor<'_> for GeneratedVisitor {
6483 type Value = GeneratedField;
6484
6485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6486 write!(formatter, "expected one of: {:?}", &FIELDS)
6487 }
6488
6489 #[allow(unused_variables)]
6490 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6491 where
6492 E: serde::de::Error,
6493 {
6494 match value {
6495 "levels" => Ok(GeneratedField::Levels),
6496 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6497 }
6498 }
6499 }
6500 deserializer.deserialize_identifier(GeneratedVisitor)
6501 }
6502 }
6503 struct GeneratedVisitor;
6504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6505 type Value = hnsw_graph::HnswNode;
6506
6507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6508 formatter.write_str("struct hummock.HnswGraph.HnswNode")
6509 }
6510
6511 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNode, V::Error>
6512 where
6513 V: serde::de::MapAccess<'de>,
6514 {
6515 let mut levels__ = None;
6516 while let Some(k) = map_.next_key()? {
6517 match k {
6518 GeneratedField::Levels => {
6519 if levels__.is_some() {
6520 return Err(serde::de::Error::duplicate_field("levels"));
6521 }
6522 levels__ = Some(map_.next_value()?);
6523 }
6524 }
6525 }
6526 Ok(hnsw_graph::HnswNode {
6527 levels: levels__.unwrap_or_default(),
6528 })
6529 }
6530 }
6531 deserializer.deserialize_struct("hummock.HnswGraph.HnswNode", FIELDS, GeneratedVisitor)
6532 }
6533}
6534impl serde::Serialize for HnswGraphFileInfo {
6535 #[allow(deprecated)]
6536 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6537 where
6538 S: serde::Serializer,
6539 {
6540 use serde::ser::SerializeStruct;
6541 let mut len = 0;
6542 if self.object_id != 0 {
6543 len += 1;
6544 }
6545 if self.file_size != 0 {
6546 len += 1;
6547 }
6548 let mut struct_ser = serializer.serialize_struct("hummock.HnswGraphFileInfo", len)?;
6549 if self.object_id != 0 {
6550 #[allow(clippy::needless_borrow)]
6551 #[allow(clippy::needless_borrows_for_generic_args)]
6552 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
6553 }
6554 if self.file_size != 0 {
6555 #[allow(clippy::needless_borrow)]
6556 #[allow(clippy::needless_borrows_for_generic_args)]
6557 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
6558 }
6559 struct_ser.end()
6560 }
6561}
6562impl<'de> serde::Deserialize<'de> for HnswGraphFileInfo {
6563 #[allow(deprecated)]
6564 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6565 where
6566 D: serde::Deserializer<'de>,
6567 {
6568 const FIELDS: &[&str] = &[
6569 "object_id",
6570 "objectId",
6571 "file_size",
6572 "fileSize",
6573 ];
6574
6575 #[allow(clippy::enum_variant_names)]
6576 enum GeneratedField {
6577 ObjectId,
6578 FileSize,
6579 }
6580 impl<'de> serde::Deserialize<'de> for GeneratedField {
6581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6582 where
6583 D: serde::Deserializer<'de>,
6584 {
6585 struct GeneratedVisitor;
6586
6587 impl serde::de::Visitor<'_> for GeneratedVisitor {
6588 type Value = GeneratedField;
6589
6590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6591 write!(formatter, "expected one of: {:?}", &FIELDS)
6592 }
6593
6594 #[allow(unused_variables)]
6595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6596 where
6597 E: serde::de::Error,
6598 {
6599 match value {
6600 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
6601 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
6602 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6603 }
6604 }
6605 }
6606 deserializer.deserialize_identifier(GeneratedVisitor)
6607 }
6608 }
6609 struct GeneratedVisitor;
6610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6611 type Value = HnswGraphFileInfo;
6612
6613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6614 formatter.write_str("struct hummock.HnswGraphFileInfo")
6615 }
6616
6617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraphFileInfo, V::Error>
6618 where
6619 V: serde::de::MapAccess<'de>,
6620 {
6621 let mut object_id__ = None;
6622 let mut file_size__ = None;
6623 while let Some(k) = map_.next_key()? {
6624 match k {
6625 GeneratedField::ObjectId => {
6626 if object_id__.is_some() {
6627 return Err(serde::de::Error::duplicate_field("objectId"));
6628 }
6629 object_id__ =
6630 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6631 ;
6632 }
6633 GeneratedField::FileSize => {
6634 if file_size__.is_some() {
6635 return Err(serde::de::Error::duplicate_field("fileSize"));
6636 }
6637 file_size__ =
6638 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6639 ;
6640 }
6641 }
6642 }
6643 Ok(HnswGraphFileInfo {
6644 object_id: object_id__.unwrap_or_default(),
6645 file_size: file_size__.unwrap_or_default(),
6646 })
6647 }
6648 }
6649 deserializer.deserialize_struct("hummock.HnswGraphFileInfo", FIELDS, GeneratedVisitor)
6650 }
6651}
6652impl serde::Serialize for HummockPinnedSnapshot {
6653 #[allow(deprecated)]
6654 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6655 where
6656 S: serde::Serializer,
6657 {
6658 use serde::ser::SerializeStruct;
6659 let mut len = 0;
6660 if self.context_id != 0 {
6661 len += 1;
6662 }
6663 if self.minimal_pinned_snapshot != 0 {
6664 len += 1;
6665 }
6666 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
6667 if self.context_id != 0 {
6668 struct_ser.serialize_field("contextId", &self.context_id)?;
6669 }
6670 if self.minimal_pinned_snapshot != 0 {
6671 #[allow(clippy::needless_borrow)]
6672 #[allow(clippy::needless_borrows_for_generic_args)]
6673 struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
6674 }
6675 struct_ser.end()
6676 }
6677}
6678impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
6679 #[allow(deprecated)]
6680 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6681 where
6682 D: serde::Deserializer<'de>,
6683 {
6684 const FIELDS: &[&str] = &[
6685 "context_id",
6686 "contextId",
6687 "minimal_pinned_snapshot",
6688 "minimalPinnedSnapshot",
6689 ];
6690
6691 #[allow(clippy::enum_variant_names)]
6692 enum GeneratedField {
6693 ContextId,
6694 MinimalPinnedSnapshot,
6695 }
6696 impl<'de> serde::Deserialize<'de> for GeneratedField {
6697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6698 where
6699 D: serde::Deserializer<'de>,
6700 {
6701 struct GeneratedVisitor;
6702
6703 impl serde::de::Visitor<'_> for GeneratedVisitor {
6704 type Value = GeneratedField;
6705
6706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6707 write!(formatter, "expected one of: {:?}", &FIELDS)
6708 }
6709
6710 #[allow(unused_variables)]
6711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6712 where
6713 E: serde::de::Error,
6714 {
6715 match value {
6716 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6717 "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
6718 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6719 }
6720 }
6721 }
6722 deserializer.deserialize_identifier(GeneratedVisitor)
6723 }
6724 }
6725 struct GeneratedVisitor;
6726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6727 type Value = HummockPinnedSnapshot;
6728
6729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6730 formatter.write_str("struct hummock.HummockPinnedSnapshot")
6731 }
6732
6733 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
6734 where
6735 V: serde::de::MapAccess<'de>,
6736 {
6737 let mut context_id__ = None;
6738 let mut minimal_pinned_snapshot__ = None;
6739 while let Some(k) = map_.next_key()? {
6740 match k {
6741 GeneratedField::ContextId => {
6742 if context_id__.is_some() {
6743 return Err(serde::de::Error::duplicate_field("contextId"));
6744 }
6745 context_id__ =
6746 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6747 ;
6748 }
6749 GeneratedField::MinimalPinnedSnapshot => {
6750 if minimal_pinned_snapshot__.is_some() {
6751 return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
6752 }
6753 minimal_pinned_snapshot__ =
6754 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6755 ;
6756 }
6757 }
6758 }
6759 Ok(HummockPinnedSnapshot {
6760 context_id: context_id__.unwrap_or_default(),
6761 minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
6762 })
6763 }
6764 }
6765 deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
6766 }
6767}
6768impl serde::Serialize for HummockPinnedVersion {
6769 #[allow(deprecated)]
6770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6771 where
6772 S: serde::Serializer,
6773 {
6774 use serde::ser::SerializeStruct;
6775 let mut len = 0;
6776 if self.context_id != 0 {
6777 len += 1;
6778 }
6779 if self.min_pinned_id != 0 {
6780 len += 1;
6781 }
6782 let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
6783 if self.context_id != 0 {
6784 struct_ser.serialize_field("contextId", &self.context_id)?;
6785 }
6786 if self.min_pinned_id != 0 {
6787 #[allow(clippy::needless_borrow)]
6788 #[allow(clippy::needless_borrows_for_generic_args)]
6789 struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
6790 }
6791 struct_ser.end()
6792 }
6793}
6794impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
6795 #[allow(deprecated)]
6796 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6797 where
6798 D: serde::Deserializer<'de>,
6799 {
6800 const FIELDS: &[&str] = &[
6801 "context_id",
6802 "contextId",
6803 "min_pinned_id",
6804 "minPinnedId",
6805 ];
6806
6807 #[allow(clippy::enum_variant_names)]
6808 enum GeneratedField {
6809 ContextId,
6810 MinPinnedId,
6811 }
6812 impl<'de> serde::Deserialize<'de> for GeneratedField {
6813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6814 where
6815 D: serde::Deserializer<'de>,
6816 {
6817 struct GeneratedVisitor;
6818
6819 impl serde::de::Visitor<'_> for GeneratedVisitor {
6820 type Value = GeneratedField;
6821
6822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6823 write!(formatter, "expected one of: {:?}", &FIELDS)
6824 }
6825
6826 #[allow(unused_variables)]
6827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6828 where
6829 E: serde::de::Error,
6830 {
6831 match value {
6832 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6833 "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
6834 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6835 }
6836 }
6837 }
6838 deserializer.deserialize_identifier(GeneratedVisitor)
6839 }
6840 }
6841 struct GeneratedVisitor;
6842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6843 type Value = HummockPinnedVersion;
6844
6845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6846 formatter.write_str("struct hummock.HummockPinnedVersion")
6847 }
6848
6849 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
6850 where
6851 V: serde::de::MapAccess<'de>,
6852 {
6853 let mut context_id__ = None;
6854 let mut min_pinned_id__ = None;
6855 while let Some(k) = map_.next_key()? {
6856 match k {
6857 GeneratedField::ContextId => {
6858 if context_id__.is_some() {
6859 return Err(serde::de::Error::duplicate_field("contextId"));
6860 }
6861 context_id__ =
6862 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6863 ;
6864 }
6865 GeneratedField::MinPinnedId => {
6866 if min_pinned_id__.is_some() {
6867 return Err(serde::de::Error::duplicate_field("minPinnedId"));
6868 }
6869 min_pinned_id__ =
6870 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6871 ;
6872 }
6873 }
6874 }
6875 Ok(HummockPinnedVersion {
6876 context_id: context_id__.unwrap_or_default(),
6877 min_pinned_id: min_pinned_id__.unwrap_or_default(),
6878 })
6879 }
6880 }
6881 deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
6882 }
6883}
6884impl serde::Serialize for HummockVersion {
6885 #[allow(deprecated)]
6886 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6887 where
6888 S: serde::Serializer,
6889 {
6890 use serde::ser::SerializeStruct;
6891 let mut len = 0;
6892 if self.id != 0 {
6893 len += 1;
6894 }
6895 if !self.levels.is_empty() {
6896 len += 1;
6897 }
6898 if self.max_committed_epoch != 0 {
6899 len += 1;
6900 }
6901 if !self.table_watermarks.is_empty() {
6902 len += 1;
6903 }
6904 if !self.table_change_logs.is_empty() {
6905 len += 1;
6906 }
6907 if !self.state_table_info.is_empty() {
6908 len += 1;
6909 }
6910 if !self.vector_indexes.is_empty() {
6911 len += 1;
6912 }
6913 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
6914 if self.id != 0 {
6915 #[allow(clippy::needless_borrow)]
6916 #[allow(clippy::needless_borrows_for_generic_args)]
6917 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6918 }
6919 if !self.levels.is_empty() {
6920 struct_ser.serialize_field("levels", &self.levels)?;
6921 }
6922 if self.max_committed_epoch != 0 {
6923 #[allow(clippy::needless_borrow)]
6924 #[allow(clippy::needless_borrows_for_generic_args)]
6925 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6926 }
6927 if !self.table_watermarks.is_empty() {
6928 struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
6929 }
6930 if !self.table_change_logs.is_empty() {
6931 struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
6932 }
6933 if !self.state_table_info.is_empty() {
6934 struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
6935 }
6936 if !self.vector_indexes.is_empty() {
6937 struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
6938 }
6939 struct_ser.end()
6940 }
6941}
6942impl<'de> serde::Deserialize<'de> for HummockVersion {
6943 #[allow(deprecated)]
6944 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6945 where
6946 D: serde::Deserializer<'de>,
6947 {
6948 const FIELDS: &[&str] = &[
6949 "id",
6950 "levels",
6951 "max_committed_epoch",
6952 "maxCommittedEpoch",
6953 "table_watermarks",
6954 "tableWatermarks",
6955 "table_change_logs",
6956 "tableChangeLogs",
6957 "state_table_info",
6958 "stateTableInfo",
6959 "vector_indexes",
6960 "vectorIndexes",
6961 ];
6962
6963 #[allow(clippy::enum_variant_names)]
6964 enum GeneratedField {
6965 Id,
6966 Levels,
6967 MaxCommittedEpoch,
6968 TableWatermarks,
6969 TableChangeLogs,
6970 StateTableInfo,
6971 VectorIndexes,
6972 }
6973 impl<'de> serde::Deserialize<'de> for GeneratedField {
6974 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6975 where
6976 D: serde::Deserializer<'de>,
6977 {
6978 struct GeneratedVisitor;
6979
6980 impl serde::de::Visitor<'_> for GeneratedVisitor {
6981 type Value = GeneratedField;
6982
6983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6984 write!(formatter, "expected one of: {:?}", &FIELDS)
6985 }
6986
6987 #[allow(unused_variables)]
6988 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6989 where
6990 E: serde::de::Error,
6991 {
6992 match value {
6993 "id" => Ok(GeneratedField::Id),
6994 "levels" => Ok(GeneratedField::Levels),
6995 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6996 "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
6997 "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
6998 "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
6999 "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
7000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7001 }
7002 }
7003 }
7004 deserializer.deserialize_identifier(GeneratedVisitor)
7005 }
7006 }
7007 struct GeneratedVisitor;
7008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7009 type Value = HummockVersion;
7010
7011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7012 formatter.write_str("struct hummock.HummockVersion")
7013 }
7014
7015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
7016 where
7017 V: serde::de::MapAccess<'de>,
7018 {
7019 let mut id__ = None;
7020 let mut levels__ = None;
7021 let mut max_committed_epoch__ = None;
7022 let mut table_watermarks__ = None;
7023 let mut table_change_logs__ = None;
7024 let mut state_table_info__ = None;
7025 let mut vector_indexes__ = None;
7026 while let Some(k) = map_.next_key()? {
7027 match k {
7028 GeneratedField::Id => {
7029 if id__.is_some() {
7030 return Err(serde::de::Error::duplicate_field("id"));
7031 }
7032 id__ =
7033 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7034 ;
7035 }
7036 GeneratedField::Levels => {
7037 if levels__.is_some() {
7038 return Err(serde::de::Error::duplicate_field("levels"));
7039 }
7040 levels__ = Some(
7041 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7042 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7043 );
7044 }
7045 GeneratedField::MaxCommittedEpoch => {
7046 if max_committed_epoch__.is_some() {
7047 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
7048 }
7049 max_committed_epoch__ =
7050 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7051 ;
7052 }
7053 GeneratedField::TableWatermarks => {
7054 if table_watermarks__.is_some() {
7055 return Err(serde::de::Error::duplicate_field("tableWatermarks"));
7056 }
7057 table_watermarks__ = Some(
7058 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7059 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7060 );
7061 }
7062 GeneratedField::TableChangeLogs => {
7063 if table_change_logs__.is_some() {
7064 return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
7065 }
7066 table_change_logs__ = Some(
7067 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7068 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7069 );
7070 }
7071 GeneratedField::StateTableInfo => {
7072 if state_table_info__.is_some() {
7073 return Err(serde::de::Error::duplicate_field("stateTableInfo"));
7074 }
7075 state_table_info__ = Some(
7076 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7077 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7078 );
7079 }
7080 GeneratedField::VectorIndexes => {
7081 if vector_indexes__.is_some() {
7082 return Err(serde::de::Error::duplicate_field("vectorIndexes"));
7083 }
7084 vector_indexes__ = Some(
7085 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7086 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7087 );
7088 }
7089 }
7090 }
7091 Ok(HummockVersion {
7092 id: id__.unwrap_or_default(),
7093 levels: levels__.unwrap_or_default(),
7094 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
7095 table_watermarks: table_watermarks__.unwrap_or_default(),
7096 table_change_logs: table_change_logs__.unwrap_or_default(),
7097 state_table_info: state_table_info__.unwrap_or_default(),
7098 vector_indexes: vector_indexes__.unwrap_or_default(),
7099 })
7100 }
7101 }
7102 deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
7103 }
7104}
7105impl serde::Serialize for hummock_version::Levels {
7106 #[allow(deprecated)]
7107 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7108 where
7109 S: serde::Serializer,
7110 {
7111 use serde::ser::SerializeStruct;
7112 let mut len = 0;
7113 if !self.levels.is_empty() {
7114 len += 1;
7115 }
7116 if self.l0.is_some() {
7117 len += 1;
7118 }
7119 if self.group_id != 0 {
7120 len += 1;
7121 }
7122 if self.parent_group_id != 0 {
7123 len += 1;
7124 }
7125 if !self.member_table_ids.is_empty() {
7126 len += 1;
7127 }
7128 if self.compaction_group_version_id != 0 {
7129 len += 1;
7130 }
7131 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
7132 if !self.levels.is_empty() {
7133 struct_ser.serialize_field("levels", &self.levels)?;
7134 }
7135 if let Some(v) = self.l0.as_ref() {
7136 struct_ser.serialize_field("l0", v)?;
7137 }
7138 if self.group_id != 0 {
7139 #[allow(clippy::needless_borrow)]
7140 #[allow(clippy::needless_borrows_for_generic_args)]
7141 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
7142 }
7143 if self.parent_group_id != 0 {
7144 #[allow(clippy::needless_borrow)]
7145 #[allow(clippy::needless_borrows_for_generic_args)]
7146 struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
7147 }
7148 if !self.member_table_ids.is_empty() {
7149 struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
7150 }
7151 if self.compaction_group_version_id != 0 {
7152 #[allow(clippy::needless_borrow)]
7153 #[allow(clippy::needless_borrows_for_generic_args)]
7154 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
7155 }
7156 struct_ser.end()
7157 }
7158}
7159impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
7160 #[allow(deprecated)]
7161 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7162 where
7163 D: serde::Deserializer<'de>,
7164 {
7165 const FIELDS: &[&str] = &[
7166 "levels",
7167 "l0",
7168 "group_id",
7169 "groupId",
7170 "parent_group_id",
7171 "parentGroupId",
7172 "member_table_ids",
7173 "memberTableIds",
7174 "compaction_group_version_id",
7175 "compactionGroupVersionId",
7176 ];
7177
7178 #[allow(clippy::enum_variant_names)]
7179 enum GeneratedField {
7180 Levels,
7181 L0,
7182 GroupId,
7183 ParentGroupId,
7184 MemberTableIds,
7185 CompactionGroupVersionId,
7186 }
7187 impl<'de> serde::Deserialize<'de> for GeneratedField {
7188 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7189 where
7190 D: serde::Deserializer<'de>,
7191 {
7192 struct GeneratedVisitor;
7193
7194 impl serde::de::Visitor<'_> for GeneratedVisitor {
7195 type Value = GeneratedField;
7196
7197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7198 write!(formatter, "expected one of: {:?}", &FIELDS)
7199 }
7200
7201 #[allow(unused_variables)]
7202 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7203 where
7204 E: serde::de::Error,
7205 {
7206 match value {
7207 "levels" => Ok(GeneratedField::Levels),
7208 "l0" => Ok(GeneratedField::L0),
7209 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
7210 "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
7211 "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
7212 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
7213 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7214 }
7215 }
7216 }
7217 deserializer.deserialize_identifier(GeneratedVisitor)
7218 }
7219 }
7220 struct GeneratedVisitor;
7221 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7222 type Value = hummock_version::Levels;
7223
7224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7225 formatter.write_str("struct hummock.HummockVersion.Levels")
7226 }
7227
7228 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
7229 where
7230 V: serde::de::MapAccess<'de>,
7231 {
7232 let mut levels__ = None;
7233 let mut l0__ = None;
7234 let mut group_id__ = None;
7235 let mut parent_group_id__ = None;
7236 let mut member_table_ids__ = None;
7237 let mut compaction_group_version_id__ = None;
7238 while let Some(k) = map_.next_key()? {
7239 match k {
7240 GeneratedField::Levels => {
7241 if levels__.is_some() {
7242 return Err(serde::de::Error::duplicate_field("levels"));
7243 }
7244 levels__ = Some(map_.next_value()?);
7245 }
7246 GeneratedField::L0 => {
7247 if l0__.is_some() {
7248 return Err(serde::de::Error::duplicate_field("l0"));
7249 }
7250 l0__ = map_.next_value()?;
7251 }
7252 GeneratedField::GroupId => {
7253 if group_id__.is_some() {
7254 return Err(serde::de::Error::duplicate_field("groupId"));
7255 }
7256 group_id__ =
7257 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7258 ;
7259 }
7260 GeneratedField::ParentGroupId => {
7261 if parent_group_id__.is_some() {
7262 return Err(serde::de::Error::duplicate_field("parentGroupId"));
7263 }
7264 parent_group_id__ =
7265 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7266 ;
7267 }
7268 GeneratedField::MemberTableIds => {
7269 if member_table_ids__.is_some() {
7270 return Err(serde::de::Error::duplicate_field("memberTableIds"));
7271 }
7272 member_table_ids__ =
7273 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7274 .into_iter().map(|x| x.0).collect())
7275 ;
7276 }
7277 GeneratedField::CompactionGroupVersionId => {
7278 if compaction_group_version_id__.is_some() {
7279 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
7280 }
7281 compaction_group_version_id__ =
7282 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7283 ;
7284 }
7285 }
7286 }
7287 Ok(hummock_version::Levels {
7288 levels: levels__.unwrap_or_default(),
7289 l0: l0__,
7290 group_id: group_id__.unwrap_or_default(),
7291 parent_group_id: parent_group_id__.unwrap_or_default(),
7292 member_table_ids: member_table_ids__.unwrap_or_default(),
7293 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
7294 })
7295 }
7296 }
7297 deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
7298 }
7299}
7300impl serde::Serialize for HummockVersionArchive {
7301 #[allow(deprecated)]
7302 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7303 where
7304 S: serde::Serializer,
7305 {
7306 use serde::ser::SerializeStruct;
7307 let mut len = 0;
7308 if self.version.is_some() {
7309 len += 1;
7310 }
7311 if !self.version_deltas.is_empty() {
7312 len += 1;
7313 }
7314 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
7315 if let Some(v) = self.version.as_ref() {
7316 struct_ser.serialize_field("version", v)?;
7317 }
7318 if !self.version_deltas.is_empty() {
7319 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
7320 }
7321 struct_ser.end()
7322 }
7323}
7324impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
7325 #[allow(deprecated)]
7326 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7327 where
7328 D: serde::Deserializer<'de>,
7329 {
7330 const FIELDS: &[&str] = &[
7331 "version",
7332 "version_deltas",
7333 "versionDeltas",
7334 ];
7335
7336 #[allow(clippy::enum_variant_names)]
7337 enum GeneratedField {
7338 Version,
7339 VersionDeltas,
7340 }
7341 impl<'de> serde::Deserialize<'de> for GeneratedField {
7342 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7343 where
7344 D: serde::Deserializer<'de>,
7345 {
7346 struct GeneratedVisitor;
7347
7348 impl serde::de::Visitor<'_> for GeneratedVisitor {
7349 type Value = GeneratedField;
7350
7351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7352 write!(formatter, "expected one of: {:?}", &FIELDS)
7353 }
7354
7355 #[allow(unused_variables)]
7356 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7357 where
7358 E: serde::de::Error,
7359 {
7360 match value {
7361 "version" => Ok(GeneratedField::Version),
7362 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
7363 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7364 }
7365 }
7366 }
7367 deserializer.deserialize_identifier(GeneratedVisitor)
7368 }
7369 }
7370 struct GeneratedVisitor;
7371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7372 type Value = HummockVersionArchive;
7373
7374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7375 formatter.write_str("struct hummock.HummockVersionArchive")
7376 }
7377
7378 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
7379 where
7380 V: serde::de::MapAccess<'de>,
7381 {
7382 let mut version__ = None;
7383 let mut version_deltas__ = None;
7384 while let Some(k) = map_.next_key()? {
7385 match k {
7386 GeneratedField::Version => {
7387 if version__.is_some() {
7388 return Err(serde::de::Error::duplicate_field("version"));
7389 }
7390 version__ = map_.next_value()?;
7391 }
7392 GeneratedField::VersionDeltas => {
7393 if version_deltas__.is_some() {
7394 return Err(serde::de::Error::duplicate_field("versionDeltas"));
7395 }
7396 version_deltas__ = Some(map_.next_value()?);
7397 }
7398 }
7399 }
7400 Ok(HummockVersionArchive {
7401 version: version__,
7402 version_deltas: version_deltas__.unwrap_or_default(),
7403 })
7404 }
7405 }
7406 deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
7407 }
7408}
7409impl serde::Serialize for HummockVersionCheckpoint {
7410 #[allow(deprecated)]
7411 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7412 where
7413 S: serde::Serializer,
7414 {
7415 use serde::ser::SerializeStruct;
7416 let mut len = 0;
7417 if self.version.is_some() {
7418 len += 1;
7419 }
7420 if !self.stale_objects.is_empty() {
7421 len += 1;
7422 }
7423 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
7424 if let Some(v) = self.version.as_ref() {
7425 struct_ser.serialize_field("version", v)?;
7426 }
7427 if !self.stale_objects.is_empty() {
7428 struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
7429 }
7430 struct_ser.end()
7431 }
7432}
7433impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
7434 #[allow(deprecated)]
7435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7436 where
7437 D: serde::Deserializer<'de>,
7438 {
7439 const FIELDS: &[&str] = &[
7440 "version",
7441 "stale_objects",
7442 "staleObjects",
7443 ];
7444
7445 #[allow(clippy::enum_variant_names)]
7446 enum GeneratedField {
7447 Version,
7448 StaleObjects,
7449 }
7450 impl<'de> serde::Deserialize<'de> for GeneratedField {
7451 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7452 where
7453 D: serde::Deserializer<'de>,
7454 {
7455 struct GeneratedVisitor;
7456
7457 impl serde::de::Visitor<'_> for GeneratedVisitor {
7458 type Value = GeneratedField;
7459
7460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7461 write!(formatter, "expected one of: {:?}", &FIELDS)
7462 }
7463
7464 #[allow(unused_variables)]
7465 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7466 where
7467 E: serde::de::Error,
7468 {
7469 match value {
7470 "version" => Ok(GeneratedField::Version),
7471 "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
7472 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7473 }
7474 }
7475 }
7476 deserializer.deserialize_identifier(GeneratedVisitor)
7477 }
7478 }
7479 struct GeneratedVisitor;
7480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7481 type Value = HummockVersionCheckpoint;
7482
7483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7484 formatter.write_str("struct hummock.HummockVersionCheckpoint")
7485 }
7486
7487 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
7488 where
7489 V: serde::de::MapAccess<'de>,
7490 {
7491 let mut version__ = None;
7492 let mut stale_objects__ = None;
7493 while let Some(k) = map_.next_key()? {
7494 match k {
7495 GeneratedField::Version => {
7496 if version__.is_some() {
7497 return Err(serde::de::Error::duplicate_field("version"));
7498 }
7499 version__ = map_.next_value()?;
7500 }
7501 GeneratedField::StaleObjects => {
7502 if stale_objects__.is_some() {
7503 return Err(serde::de::Error::duplicate_field("staleObjects"));
7504 }
7505 stale_objects__ = Some(
7506 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7507 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7508 );
7509 }
7510 }
7511 }
7512 Ok(HummockVersionCheckpoint {
7513 version: version__,
7514 stale_objects: stale_objects__.unwrap_or_default(),
7515 })
7516 }
7517 }
7518 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
7519 }
7520}
7521impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
7522 #[allow(deprecated)]
7523 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7524 where
7525 S: serde::Serializer,
7526 {
7527 use serde::ser::SerializeStruct;
7528 let mut len = 0;
7529 if !self.id.is_empty() {
7530 len += 1;
7531 }
7532 if self.total_file_size != 0 {
7533 len += 1;
7534 }
7535 if !self.vector_files.is_empty() {
7536 len += 1;
7537 }
7538 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
7539 if !self.id.is_empty() {
7540 struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7541 }
7542 if self.total_file_size != 0 {
7543 #[allow(clippy::needless_borrow)]
7544 #[allow(clippy::needless_borrows_for_generic_args)]
7545 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7546 }
7547 if !self.vector_files.is_empty() {
7548 struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
7549 }
7550 struct_ser.end()
7551 }
7552}
7553impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
7554 #[allow(deprecated)]
7555 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7556 where
7557 D: serde::Deserializer<'de>,
7558 {
7559 const FIELDS: &[&str] = &[
7560 "id",
7561 "total_file_size",
7562 "totalFileSize",
7563 "vector_files",
7564 "vectorFiles",
7565 ];
7566
7567 #[allow(clippy::enum_variant_names)]
7568 enum GeneratedField {
7569 Id,
7570 TotalFileSize,
7571 VectorFiles,
7572 }
7573 impl<'de> serde::Deserialize<'de> for GeneratedField {
7574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7575 where
7576 D: serde::Deserializer<'de>,
7577 {
7578 struct GeneratedVisitor;
7579
7580 impl serde::de::Visitor<'_> for GeneratedVisitor {
7581 type Value = GeneratedField;
7582
7583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7584 write!(formatter, "expected one of: {:?}", &FIELDS)
7585 }
7586
7587 #[allow(unused_variables)]
7588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7589 where
7590 E: serde::de::Error,
7591 {
7592 match value {
7593 "id" => Ok(GeneratedField::Id),
7594 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7595 "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
7596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7597 }
7598 }
7599 }
7600 deserializer.deserialize_identifier(GeneratedVisitor)
7601 }
7602 }
7603 struct GeneratedVisitor;
7604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7605 type Value = hummock_version_checkpoint::StaleObjects;
7606
7607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7608 formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
7609 }
7610
7611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
7612 where
7613 V: serde::de::MapAccess<'de>,
7614 {
7615 let mut id__ = None;
7616 let mut total_file_size__ = None;
7617 let mut vector_files__ = None;
7618 while let Some(k) = map_.next_key()? {
7619 match k {
7620 GeneratedField::Id => {
7621 if id__.is_some() {
7622 return Err(serde::de::Error::duplicate_field("id"));
7623 }
7624 id__ =
7625 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7626 .into_iter().map(|x| x.0).collect())
7627 ;
7628 }
7629 GeneratedField::TotalFileSize => {
7630 if total_file_size__.is_some() {
7631 return Err(serde::de::Error::duplicate_field("totalFileSize"));
7632 }
7633 total_file_size__ =
7634 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7635 ;
7636 }
7637 GeneratedField::VectorFiles => {
7638 if vector_files__.is_some() {
7639 return Err(serde::de::Error::duplicate_field("vectorFiles"));
7640 }
7641 vector_files__ = Some(map_.next_value()?);
7642 }
7643 }
7644 }
7645 Ok(hummock_version_checkpoint::StaleObjects {
7646 id: id__.unwrap_or_default(),
7647 total_file_size: total_file_size__.unwrap_or_default(),
7648 vector_files: vector_files__.unwrap_or_default(),
7649 })
7650 }
7651 }
7652 deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
7653 }
7654}
7655impl serde::Serialize for HummockVersionCheckpointEnvelope {
7656 #[allow(deprecated)]
7657 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7658 where
7659 S: serde::Serializer,
7660 {
7661 use serde::ser::SerializeStruct;
7662 let mut len = 0;
7663 if self.compression_algorithm != 0 {
7664 len += 1;
7665 }
7666 if !self.payload.is_empty() {
7667 len += 1;
7668 }
7669 if self.checksum.is_some() {
7670 len += 1;
7671 }
7672 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpointEnvelope", len)?;
7673 if self.compression_algorithm != 0 {
7674 let v = CheckpointCompressionAlgorithm::try_from(self.compression_algorithm)
7675 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compression_algorithm)))?;
7676 struct_ser.serialize_field("compressionAlgorithm", &v)?;
7677 }
7678 if !self.payload.is_empty() {
7679 #[allow(clippy::needless_borrow)]
7680 #[allow(clippy::needless_borrows_for_generic_args)]
7681 struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?;
7682 }
7683 if let Some(v) = self.checksum.as_ref() {
7684 #[allow(clippy::needless_borrow)]
7685 #[allow(clippy::needless_borrows_for_generic_args)]
7686 struct_ser.serialize_field("checksum", ToString::to_string(&v).as_str())?;
7687 }
7688 struct_ser.end()
7689 }
7690}
7691impl<'de> serde::Deserialize<'de> for HummockVersionCheckpointEnvelope {
7692 #[allow(deprecated)]
7693 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7694 where
7695 D: serde::Deserializer<'de>,
7696 {
7697 const FIELDS: &[&str] = &[
7698 "compression_algorithm",
7699 "compressionAlgorithm",
7700 "payload",
7701 "checksum",
7702 ];
7703
7704 #[allow(clippy::enum_variant_names)]
7705 enum GeneratedField {
7706 CompressionAlgorithm,
7707 Payload,
7708 Checksum,
7709 }
7710 impl<'de> serde::Deserialize<'de> for GeneratedField {
7711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7712 where
7713 D: serde::Deserializer<'de>,
7714 {
7715 struct GeneratedVisitor;
7716
7717 impl serde::de::Visitor<'_> for GeneratedVisitor {
7718 type Value = GeneratedField;
7719
7720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7721 write!(formatter, "expected one of: {:?}", &FIELDS)
7722 }
7723
7724 #[allow(unused_variables)]
7725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7726 where
7727 E: serde::de::Error,
7728 {
7729 match value {
7730 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
7731 "payload" => Ok(GeneratedField::Payload),
7732 "checksum" => Ok(GeneratedField::Checksum),
7733 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7734 }
7735 }
7736 }
7737 deserializer.deserialize_identifier(GeneratedVisitor)
7738 }
7739 }
7740 struct GeneratedVisitor;
7741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7742 type Value = HummockVersionCheckpointEnvelope;
7743
7744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7745 formatter.write_str("struct hummock.HummockVersionCheckpointEnvelope")
7746 }
7747
7748 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpointEnvelope, V::Error>
7749 where
7750 V: serde::de::MapAccess<'de>,
7751 {
7752 let mut compression_algorithm__ = None;
7753 let mut payload__ = None;
7754 let mut checksum__ = None;
7755 while let Some(k) = map_.next_key()? {
7756 match k {
7757 GeneratedField::CompressionAlgorithm => {
7758 if compression_algorithm__.is_some() {
7759 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
7760 }
7761 compression_algorithm__ = Some(map_.next_value::<CheckpointCompressionAlgorithm>()? as i32);
7762 }
7763 GeneratedField::Payload => {
7764 if payload__.is_some() {
7765 return Err(serde::de::Error::duplicate_field("payload"));
7766 }
7767 payload__ =
7768 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7769 ;
7770 }
7771 GeneratedField::Checksum => {
7772 if checksum__.is_some() {
7773 return Err(serde::de::Error::duplicate_field("checksum"));
7774 }
7775 checksum__ =
7776 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7777 ;
7778 }
7779 }
7780 }
7781 Ok(HummockVersionCheckpointEnvelope {
7782 compression_algorithm: compression_algorithm__.unwrap_or_default(),
7783 payload: payload__.unwrap_or_default(),
7784 checksum: checksum__,
7785 })
7786 }
7787 }
7788 deserializer.deserialize_struct("hummock.HummockVersionCheckpointEnvelope", FIELDS, GeneratedVisitor)
7789 }
7790}
7791impl serde::Serialize for HummockVersionDelta {
7792 #[allow(deprecated)]
7793 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7794 where
7795 S: serde::Serializer,
7796 {
7797 use serde::ser::SerializeStruct;
7798 let mut len = 0;
7799 if self.id != 0 {
7800 len += 1;
7801 }
7802 if self.prev_id != 0 {
7803 len += 1;
7804 }
7805 if !self.group_deltas.is_empty() {
7806 len += 1;
7807 }
7808 if self.max_committed_epoch != 0 {
7809 len += 1;
7810 }
7811 if self.trivial_move {
7812 len += 1;
7813 }
7814 if !self.new_table_watermarks.is_empty() {
7815 len += 1;
7816 }
7817 if !self.removed_table_ids.is_empty() {
7818 len += 1;
7819 }
7820 if !self.change_log_delta.is_empty() {
7821 len += 1;
7822 }
7823 if !self.state_table_info_delta.is_empty() {
7824 len += 1;
7825 }
7826 if !self.vector_index_delta.is_empty() {
7827 len += 1;
7828 }
7829 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
7830 if self.id != 0 {
7831 #[allow(clippy::needless_borrow)]
7832 #[allow(clippy::needless_borrows_for_generic_args)]
7833 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7834 }
7835 if self.prev_id != 0 {
7836 #[allow(clippy::needless_borrow)]
7837 #[allow(clippy::needless_borrows_for_generic_args)]
7838 struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
7839 }
7840 if !self.group_deltas.is_empty() {
7841 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7842 }
7843 if self.max_committed_epoch != 0 {
7844 #[allow(clippy::needless_borrow)]
7845 #[allow(clippy::needless_borrows_for_generic_args)]
7846 struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
7847 }
7848 if self.trivial_move {
7849 struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
7850 }
7851 if !self.new_table_watermarks.is_empty() {
7852 struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
7853 }
7854 if !self.removed_table_ids.is_empty() {
7855 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
7856 }
7857 if !self.change_log_delta.is_empty() {
7858 struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
7859 }
7860 if !self.state_table_info_delta.is_empty() {
7861 struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
7862 }
7863 if !self.vector_index_delta.is_empty() {
7864 struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
7865 }
7866 struct_ser.end()
7867 }
7868}
7869impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
7870 #[allow(deprecated)]
7871 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7872 where
7873 D: serde::Deserializer<'de>,
7874 {
7875 const FIELDS: &[&str] = &[
7876 "id",
7877 "prev_id",
7878 "prevId",
7879 "group_deltas",
7880 "groupDeltas",
7881 "max_committed_epoch",
7882 "maxCommittedEpoch",
7883 "trivial_move",
7884 "trivialMove",
7885 "new_table_watermarks",
7886 "newTableWatermarks",
7887 "removed_table_ids",
7888 "removedTableIds",
7889 "change_log_delta",
7890 "changeLogDelta",
7891 "state_table_info_delta",
7892 "stateTableInfoDelta",
7893 "vector_index_delta",
7894 "vectorIndexDelta",
7895 ];
7896
7897 #[allow(clippy::enum_variant_names)]
7898 enum GeneratedField {
7899 Id,
7900 PrevId,
7901 GroupDeltas,
7902 MaxCommittedEpoch,
7903 TrivialMove,
7904 NewTableWatermarks,
7905 RemovedTableIds,
7906 ChangeLogDelta,
7907 StateTableInfoDelta,
7908 VectorIndexDelta,
7909 }
7910 impl<'de> serde::Deserialize<'de> for GeneratedField {
7911 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7912 where
7913 D: serde::Deserializer<'de>,
7914 {
7915 struct GeneratedVisitor;
7916
7917 impl serde::de::Visitor<'_> for GeneratedVisitor {
7918 type Value = GeneratedField;
7919
7920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7921 write!(formatter, "expected one of: {:?}", &FIELDS)
7922 }
7923
7924 #[allow(unused_variables)]
7925 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7926 where
7927 E: serde::de::Error,
7928 {
7929 match value {
7930 "id" => Ok(GeneratedField::Id),
7931 "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
7932 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
7933 "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
7934 "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
7935 "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
7936 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7937 "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
7938 "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
7939 "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
7940 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7941 }
7942 }
7943 }
7944 deserializer.deserialize_identifier(GeneratedVisitor)
7945 }
7946 }
7947 struct GeneratedVisitor;
7948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7949 type Value = HummockVersionDelta;
7950
7951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7952 formatter.write_str("struct hummock.HummockVersionDelta")
7953 }
7954
7955 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
7956 where
7957 V: serde::de::MapAccess<'de>,
7958 {
7959 let mut id__ = None;
7960 let mut prev_id__ = None;
7961 let mut group_deltas__ = None;
7962 let mut max_committed_epoch__ = None;
7963 let mut trivial_move__ = None;
7964 let mut new_table_watermarks__ = None;
7965 let mut removed_table_ids__ = None;
7966 let mut change_log_delta__ = None;
7967 let mut state_table_info_delta__ = None;
7968 let mut vector_index_delta__ = None;
7969 while let Some(k) = map_.next_key()? {
7970 match k {
7971 GeneratedField::Id => {
7972 if id__.is_some() {
7973 return Err(serde::de::Error::duplicate_field("id"));
7974 }
7975 id__ =
7976 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7977 ;
7978 }
7979 GeneratedField::PrevId => {
7980 if prev_id__.is_some() {
7981 return Err(serde::de::Error::duplicate_field("prevId"));
7982 }
7983 prev_id__ =
7984 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7985 ;
7986 }
7987 GeneratedField::GroupDeltas => {
7988 if group_deltas__.is_some() {
7989 return Err(serde::de::Error::duplicate_field("groupDeltas"));
7990 }
7991 group_deltas__ = Some(
7992 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7993 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
7994 );
7995 }
7996 GeneratedField::MaxCommittedEpoch => {
7997 if max_committed_epoch__.is_some() {
7998 return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
7999 }
8000 max_committed_epoch__ =
8001 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8002 ;
8003 }
8004 GeneratedField::TrivialMove => {
8005 if trivial_move__.is_some() {
8006 return Err(serde::de::Error::duplicate_field("trivialMove"));
8007 }
8008 trivial_move__ = Some(map_.next_value()?);
8009 }
8010 GeneratedField::NewTableWatermarks => {
8011 if new_table_watermarks__.is_some() {
8012 return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
8013 }
8014 new_table_watermarks__ = Some(
8015 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8016 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8017 );
8018 }
8019 GeneratedField::RemovedTableIds => {
8020 if removed_table_ids__.is_some() {
8021 return Err(serde::de::Error::duplicate_field("removedTableIds"));
8022 }
8023 removed_table_ids__ =
8024 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8025 .into_iter().map(|x| x.0).collect())
8026 ;
8027 }
8028 GeneratedField::ChangeLogDelta => {
8029 if change_log_delta__.is_some() {
8030 return Err(serde::de::Error::duplicate_field("changeLogDelta"));
8031 }
8032 change_log_delta__ = Some(
8033 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8034 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8035 );
8036 }
8037 GeneratedField::StateTableInfoDelta => {
8038 if state_table_info_delta__.is_some() {
8039 return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
8040 }
8041 state_table_info_delta__ = Some(
8042 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8043 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8044 );
8045 }
8046 GeneratedField::VectorIndexDelta => {
8047 if vector_index_delta__.is_some() {
8048 return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
8049 }
8050 vector_index_delta__ = Some(
8051 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8052 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8053 );
8054 }
8055 }
8056 }
8057 Ok(HummockVersionDelta {
8058 id: id__.unwrap_or_default(),
8059 prev_id: prev_id__.unwrap_or_default(),
8060 group_deltas: group_deltas__.unwrap_or_default(),
8061 max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
8062 trivial_move: trivial_move__.unwrap_or_default(),
8063 new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
8064 removed_table_ids: removed_table_ids__.unwrap_or_default(),
8065 change_log_delta: change_log_delta__.unwrap_or_default(),
8066 state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
8067 vector_index_delta: vector_index_delta__.unwrap_or_default(),
8068 })
8069 }
8070 }
8071 deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
8072 }
8073}
8074impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
8075 #[allow(deprecated)]
8076 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8077 where
8078 S: serde::Serializer,
8079 {
8080 use serde::ser::SerializeStruct;
8081 let mut len = 0;
8082 if self.new_log.is_some() {
8083 len += 1;
8084 }
8085 if self.truncate_epoch != 0 {
8086 len += 1;
8087 }
8088 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
8089 if let Some(v) = self.new_log.as_ref() {
8090 struct_ser.serialize_field("newLog", v)?;
8091 }
8092 if self.truncate_epoch != 0 {
8093 #[allow(clippy::needless_borrow)]
8094 #[allow(clippy::needless_borrows_for_generic_args)]
8095 struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
8096 }
8097 struct_ser.end()
8098 }
8099}
8100impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
8101 #[allow(deprecated)]
8102 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8103 where
8104 D: serde::Deserializer<'de>,
8105 {
8106 const FIELDS: &[&str] = &[
8107 "new_log",
8108 "newLog",
8109 "truncate_epoch",
8110 "truncateEpoch",
8111 ];
8112
8113 #[allow(clippy::enum_variant_names)]
8114 enum GeneratedField {
8115 NewLog,
8116 TruncateEpoch,
8117 }
8118 impl<'de> serde::Deserialize<'de> for GeneratedField {
8119 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8120 where
8121 D: serde::Deserializer<'de>,
8122 {
8123 struct GeneratedVisitor;
8124
8125 impl serde::de::Visitor<'_> for GeneratedVisitor {
8126 type Value = GeneratedField;
8127
8128 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8129 write!(formatter, "expected one of: {:?}", &FIELDS)
8130 }
8131
8132 #[allow(unused_variables)]
8133 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8134 where
8135 E: serde::de::Error,
8136 {
8137 match value {
8138 "newLog" | "new_log" => Ok(GeneratedField::NewLog),
8139 "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
8140 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8141 }
8142 }
8143 }
8144 deserializer.deserialize_identifier(GeneratedVisitor)
8145 }
8146 }
8147 struct GeneratedVisitor;
8148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8149 type Value = hummock_version_delta::ChangeLogDelta;
8150
8151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8152 formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
8153 }
8154
8155 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
8156 where
8157 V: serde::de::MapAccess<'de>,
8158 {
8159 let mut new_log__ = None;
8160 let mut truncate_epoch__ = None;
8161 while let Some(k) = map_.next_key()? {
8162 match k {
8163 GeneratedField::NewLog => {
8164 if new_log__.is_some() {
8165 return Err(serde::de::Error::duplicate_field("newLog"));
8166 }
8167 new_log__ = map_.next_value()?;
8168 }
8169 GeneratedField::TruncateEpoch => {
8170 if truncate_epoch__.is_some() {
8171 return Err(serde::de::Error::duplicate_field("truncateEpoch"));
8172 }
8173 truncate_epoch__ =
8174 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8175 ;
8176 }
8177 }
8178 }
8179 Ok(hummock_version_delta::ChangeLogDelta {
8180 new_log: new_log__,
8181 truncate_epoch: truncate_epoch__.unwrap_or_default(),
8182 })
8183 }
8184 }
8185 deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
8186 }
8187}
8188impl serde::Serialize for hummock_version_delta::GroupDeltas {
8189 #[allow(deprecated)]
8190 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8191 where
8192 S: serde::Serializer,
8193 {
8194 use serde::ser::SerializeStruct;
8195 let mut len = 0;
8196 if !self.group_deltas.is_empty() {
8197 len += 1;
8198 }
8199 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
8200 if !self.group_deltas.is_empty() {
8201 struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
8202 }
8203 struct_ser.end()
8204 }
8205}
8206impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
8207 #[allow(deprecated)]
8208 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8209 where
8210 D: serde::Deserializer<'de>,
8211 {
8212 const FIELDS: &[&str] = &[
8213 "group_deltas",
8214 "groupDeltas",
8215 ];
8216
8217 #[allow(clippy::enum_variant_names)]
8218 enum GeneratedField {
8219 GroupDeltas,
8220 }
8221 impl<'de> serde::Deserialize<'de> for GeneratedField {
8222 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8223 where
8224 D: serde::Deserializer<'de>,
8225 {
8226 struct GeneratedVisitor;
8227
8228 impl serde::de::Visitor<'_> for GeneratedVisitor {
8229 type Value = GeneratedField;
8230
8231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8232 write!(formatter, "expected one of: {:?}", &FIELDS)
8233 }
8234
8235 #[allow(unused_variables)]
8236 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8237 where
8238 E: serde::de::Error,
8239 {
8240 match value {
8241 "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
8242 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8243 }
8244 }
8245 }
8246 deserializer.deserialize_identifier(GeneratedVisitor)
8247 }
8248 }
8249 struct GeneratedVisitor;
8250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8251 type Value = hummock_version_delta::GroupDeltas;
8252
8253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8254 formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
8255 }
8256
8257 fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
8258 where
8259 V: serde::de::MapAccess<'de>,
8260 {
8261 let mut group_deltas__ = None;
8262 while let Some(k) = map_.next_key()? {
8263 match k {
8264 GeneratedField::GroupDeltas => {
8265 if group_deltas__.is_some() {
8266 return Err(serde::de::Error::duplicate_field("groupDeltas"));
8267 }
8268 group_deltas__ = Some(map_.next_value()?);
8269 }
8270 }
8271 }
8272 Ok(hummock_version_delta::GroupDeltas {
8273 group_deltas: group_deltas__.unwrap_or_default(),
8274 })
8275 }
8276 }
8277 deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
8278 }
8279}
8280impl serde::Serialize for HummockVersionDeltas {
8281 #[allow(deprecated)]
8282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8283 where
8284 S: serde::Serializer,
8285 {
8286 use serde::ser::SerializeStruct;
8287 let mut len = 0;
8288 if !self.version_deltas.is_empty() {
8289 len += 1;
8290 }
8291 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
8292 if !self.version_deltas.is_empty() {
8293 struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
8294 }
8295 struct_ser.end()
8296 }
8297}
8298impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
8299 #[allow(deprecated)]
8300 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8301 where
8302 D: serde::Deserializer<'de>,
8303 {
8304 const FIELDS: &[&str] = &[
8305 "version_deltas",
8306 "versionDeltas",
8307 ];
8308
8309 #[allow(clippy::enum_variant_names)]
8310 enum GeneratedField {
8311 VersionDeltas,
8312 }
8313 impl<'de> serde::Deserialize<'de> for GeneratedField {
8314 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8315 where
8316 D: serde::Deserializer<'de>,
8317 {
8318 struct GeneratedVisitor;
8319
8320 impl serde::de::Visitor<'_> for GeneratedVisitor {
8321 type Value = GeneratedField;
8322
8323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8324 write!(formatter, "expected one of: {:?}", &FIELDS)
8325 }
8326
8327 #[allow(unused_variables)]
8328 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8329 where
8330 E: serde::de::Error,
8331 {
8332 match value {
8333 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
8334 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8335 }
8336 }
8337 }
8338 deserializer.deserialize_identifier(GeneratedVisitor)
8339 }
8340 }
8341 struct GeneratedVisitor;
8342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8343 type Value = HummockVersionDeltas;
8344
8345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8346 formatter.write_str("struct hummock.HummockVersionDeltas")
8347 }
8348
8349 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
8350 where
8351 V: serde::de::MapAccess<'de>,
8352 {
8353 let mut version_deltas__ = None;
8354 while let Some(k) = map_.next_key()? {
8355 match k {
8356 GeneratedField::VersionDeltas => {
8357 if version_deltas__.is_some() {
8358 return Err(serde::de::Error::duplicate_field("versionDeltas"));
8359 }
8360 version_deltas__ = Some(map_.next_value()?);
8361 }
8362 }
8363 }
8364 Ok(HummockVersionDeltas {
8365 version_deltas: version_deltas__.unwrap_or_default(),
8366 })
8367 }
8368 }
8369 deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
8370 }
8371}
8372impl serde::Serialize for HummockVersionStats {
8373 #[allow(deprecated)]
8374 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8375 where
8376 S: serde::Serializer,
8377 {
8378 use serde::ser::SerializeStruct;
8379 let mut len = 0;
8380 if self.hummock_version_id != 0 {
8381 len += 1;
8382 }
8383 if !self.table_stats.is_empty() {
8384 len += 1;
8385 }
8386 let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
8387 if self.hummock_version_id != 0 {
8388 #[allow(clippy::needless_borrow)]
8389 #[allow(clippy::needless_borrows_for_generic_args)]
8390 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
8391 }
8392 if !self.table_stats.is_empty() {
8393 struct_ser.serialize_field("tableStats", &self.table_stats)?;
8394 }
8395 struct_ser.end()
8396 }
8397}
8398impl<'de> serde::Deserialize<'de> for HummockVersionStats {
8399 #[allow(deprecated)]
8400 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8401 where
8402 D: serde::Deserializer<'de>,
8403 {
8404 const FIELDS: &[&str] = &[
8405 "hummock_version_id",
8406 "hummockVersionId",
8407 "table_stats",
8408 "tableStats",
8409 ];
8410
8411 #[allow(clippy::enum_variant_names)]
8412 enum GeneratedField {
8413 HummockVersionId,
8414 TableStats,
8415 }
8416 impl<'de> serde::Deserialize<'de> for GeneratedField {
8417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8418 where
8419 D: serde::Deserializer<'de>,
8420 {
8421 struct GeneratedVisitor;
8422
8423 impl serde::de::Visitor<'_> for GeneratedVisitor {
8424 type Value = GeneratedField;
8425
8426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8427 write!(formatter, "expected one of: {:?}", &FIELDS)
8428 }
8429
8430 #[allow(unused_variables)]
8431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8432 where
8433 E: serde::de::Error,
8434 {
8435 match value {
8436 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
8437 "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
8438 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8439 }
8440 }
8441 }
8442 deserializer.deserialize_identifier(GeneratedVisitor)
8443 }
8444 }
8445 struct GeneratedVisitor;
8446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8447 type Value = HummockVersionStats;
8448
8449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8450 formatter.write_str("struct hummock.HummockVersionStats")
8451 }
8452
8453 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
8454 where
8455 V: serde::de::MapAccess<'de>,
8456 {
8457 let mut hummock_version_id__ = None;
8458 let mut table_stats__ = None;
8459 while let Some(k) = map_.next_key()? {
8460 match k {
8461 GeneratedField::HummockVersionId => {
8462 if hummock_version_id__.is_some() {
8463 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
8464 }
8465 hummock_version_id__ =
8466 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8467 ;
8468 }
8469 GeneratedField::TableStats => {
8470 if table_stats__.is_some() {
8471 return Err(serde::de::Error::duplicate_field("tableStats"));
8472 }
8473 table_stats__ = Some(
8474 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8475 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
8476 );
8477 }
8478 }
8479 }
8480 Ok(HummockVersionStats {
8481 hummock_version_id: hummock_version_id__.unwrap_or_default(),
8482 table_stats: table_stats__.unwrap_or_default(),
8483 })
8484 }
8485 }
8486 deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
8487 }
8488}
8489impl serde::Serialize for InitMetadataForReplayRequest {
8490 #[allow(deprecated)]
8491 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8492 where
8493 S: serde::Serializer,
8494 {
8495 use serde::ser::SerializeStruct;
8496 let mut len = 0;
8497 if !self.tables.is_empty() {
8498 len += 1;
8499 }
8500 if !self.compaction_groups.is_empty() {
8501 len += 1;
8502 }
8503 let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
8504 if !self.tables.is_empty() {
8505 struct_ser.serialize_field("tables", &self.tables)?;
8506 }
8507 if !self.compaction_groups.is_empty() {
8508 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
8509 }
8510 struct_ser.end()
8511 }
8512}
8513impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
8514 #[allow(deprecated)]
8515 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8516 where
8517 D: serde::Deserializer<'de>,
8518 {
8519 const FIELDS: &[&str] = &[
8520 "tables",
8521 "compaction_groups",
8522 "compactionGroups",
8523 ];
8524
8525 #[allow(clippy::enum_variant_names)]
8526 enum GeneratedField {
8527 Tables,
8528 CompactionGroups,
8529 }
8530 impl<'de> serde::Deserialize<'de> for GeneratedField {
8531 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8532 where
8533 D: serde::Deserializer<'de>,
8534 {
8535 struct GeneratedVisitor;
8536
8537 impl serde::de::Visitor<'_> for GeneratedVisitor {
8538 type Value = GeneratedField;
8539
8540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8541 write!(formatter, "expected one of: {:?}", &FIELDS)
8542 }
8543
8544 #[allow(unused_variables)]
8545 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8546 where
8547 E: serde::de::Error,
8548 {
8549 match value {
8550 "tables" => Ok(GeneratedField::Tables),
8551 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
8552 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8553 }
8554 }
8555 }
8556 deserializer.deserialize_identifier(GeneratedVisitor)
8557 }
8558 }
8559 struct GeneratedVisitor;
8560 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8561 type Value = InitMetadataForReplayRequest;
8562
8563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8564 formatter.write_str("struct hummock.InitMetadataForReplayRequest")
8565 }
8566
8567 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
8568 where
8569 V: serde::de::MapAccess<'de>,
8570 {
8571 let mut tables__ = None;
8572 let mut compaction_groups__ = None;
8573 while let Some(k) = map_.next_key()? {
8574 match k {
8575 GeneratedField::Tables => {
8576 if tables__.is_some() {
8577 return Err(serde::de::Error::duplicate_field("tables"));
8578 }
8579 tables__ = Some(map_.next_value()?);
8580 }
8581 GeneratedField::CompactionGroups => {
8582 if compaction_groups__.is_some() {
8583 return Err(serde::de::Error::duplicate_field("compactionGroups"));
8584 }
8585 compaction_groups__ = Some(map_.next_value()?);
8586 }
8587 }
8588 }
8589 Ok(InitMetadataForReplayRequest {
8590 tables: tables__.unwrap_or_default(),
8591 compaction_groups: compaction_groups__.unwrap_or_default(),
8592 })
8593 }
8594 }
8595 deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
8596 }
8597}
8598impl serde::Serialize for InitMetadataForReplayResponse {
8599 #[allow(deprecated)]
8600 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8601 where
8602 S: serde::Serializer,
8603 {
8604 use serde::ser::SerializeStruct;
8605 let len = 0;
8606 let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
8607 struct_ser.end()
8608 }
8609}
8610impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
8611 #[allow(deprecated)]
8612 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8613 where
8614 D: serde::Deserializer<'de>,
8615 {
8616 const FIELDS: &[&str] = &[
8617 ];
8618
8619 #[allow(clippy::enum_variant_names)]
8620 enum GeneratedField {
8621 }
8622 impl<'de> serde::Deserialize<'de> for GeneratedField {
8623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8624 where
8625 D: serde::Deserializer<'de>,
8626 {
8627 struct GeneratedVisitor;
8628
8629 impl serde::de::Visitor<'_> for GeneratedVisitor {
8630 type Value = GeneratedField;
8631
8632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8633 write!(formatter, "expected one of: {:?}", &FIELDS)
8634 }
8635
8636 #[allow(unused_variables)]
8637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8638 where
8639 E: serde::de::Error,
8640 {
8641 Err(serde::de::Error::unknown_field(value, FIELDS))
8642 }
8643 }
8644 deserializer.deserialize_identifier(GeneratedVisitor)
8645 }
8646 }
8647 struct GeneratedVisitor;
8648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8649 type Value = InitMetadataForReplayResponse;
8650
8651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8652 formatter.write_str("struct hummock.InitMetadataForReplayResponse")
8653 }
8654
8655 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
8656 where
8657 V: serde::de::MapAccess<'de>,
8658 {
8659 while map_.next_key::<GeneratedField>()?.is_some() {
8660 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8661 }
8662 Ok(InitMetadataForReplayResponse {
8663 })
8664 }
8665 }
8666 deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
8667 }
8668}
8669impl serde::Serialize for InputLevel {
8670 #[allow(deprecated)]
8671 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8672 where
8673 S: serde::Serializer,
8674 {
8675 use serde::ser::SerializeStruct;
8676 let mut len = 0;
8677 if self.level_idx != 0 {
8678 len += 1;
8679 }
8680 if self.level_type != 0 {
8681 len += 1;
8682 }
8683 if !self.table_infos.is_empty() {
8684 len += 1;
8685 }
8686 let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
8687 if self.level_idx != 0 {
8688 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8689 }
8690 if self.level_type != 0 {
8691 let v = LevelType::try_from(self.level_type)
8692 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
8693 struct_ser.serialize_field("levelType", &v)?;
8694 }
8695 if !self.table_infos.is_empty() {
8696 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
8697 }
8698 struct_ser.end()
8699 }
8700}
8701impl<'de> serde::Deserialize<'de> for InputLevel {
8702 #[allow(deprecated)]
8703 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8704 where
8705 D: serde::Deserializer<'de>,
8706 {
8707 const FIELDS: &[&str] = &[
8708 "level_idx",
8709 "levelIdx",
8710 "level_type",
8711 "levelType",
8712 "table_infos",
8713 "tableInfos",
8714 ];
8715
8716 #[allow(clippy::enum_variant_names)]
8717 enum GeneratedField {
8718 LevelIdx,
8719 LevelType,
8720 TableInfos,
8721 }
8722 impl<'de> serde::Deserialize<'de> for GeneratedField {
8723 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8724 where
8725 D: serde::Deserializer<'de>,
8726 {
8727 struct GeneratedVisitor;
8728
8729 impl serde::de::Visitor<'_> for GeneratedVisitor {
8730 type Value = GeneratedField;
8731
8732 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8733 write!(formatter, "expected one of: {:?}", &FIELDS)
8734 }
8735
8736 #[allow(unused_variables)]
8737 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8738 where
8739 E: serde::de::Error,
8740 {
8741 match value {
8742 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8743 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8744 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8746 }
8747 }
8748 }
8749 deserializer.deserialize_identifier(GeneratedVisitor)
8750 }
8751 }
8752 struct GeneratedVisitor;
8753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8754 type Value = InputLevel;
8755
8756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8757 formatter.write_str("struct hummock.InputLevel")
8758 }
8759
8760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
8761 where
8762 V: serde::de::MapAccess<'de>,
8763 {
8764 let mut level_idx__ = None;
8765 let mut level_type__ = None;
8766 let mut table_infos__ = None;
8767 while let Some(k) = map_.next_key()? {
8768 match k {
8769 GeneratedField::LevelIdx => {
8770 if level_idx__.is_some() {
8771 return Err(serde::de::Error::duplicate_field("levelIdx"));
8772 }
8773 level_idx__ =
8774 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8775 ;
8776 }
8777 GeneratedField::LevelType => {
8778 if level_type__.is_some() {
8779 return Err(serde::de::Error::duplicate_field("levelType"));
8780 }
8781 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8782 }
8783 GeneratedField::TableInfos => {
8784 if table_infos__.is_some() {
8785 return Err(serde::de::Error::duplicate_field("tableInfos"));
8786 }
8787 table_infos__ = Some(map_.next_value()?);
8788 }
8789 }
8790 }
8791 Ok(InputLevel {
8792 level_idx: level_idx__.unwrap_or_default(),
8793 level_type: level_type__.unwrap_or_default(),
8794 table_infos: table_infos__.unwrap_or_default(),
8795 })
8796 }
8797 }
8798 deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
8799 }
8800}
8801impl serde::Serialize for IntraLevelDelta {
8802 #[allow(deprecated)]
8803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8804 where
8805 S: serde::Serializer,
8806 {
8807 use serde::ser::SerializeStruct;
8808 let mut len = 0;
8809 if self.level_idx != 0 {
8810 len += 1;
8811 }
8812 if self.l0_sub_level_id != 0 {
8813 len += 1;
8814 }
8815 if !self.removed_table_ids.is_empty() {
8816 len += 1;
8817 }
8818 if !self.inserted_table_infos.is_empty() {
8819 len += 1;
8820 }
8821 if self.vnode_partition_count != 0 {
8822 len += 1;
8823 }
8824 if self.compaction_group_version_id != 0 {
8825 len += 1;
8826 }
8827 let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
8828 if self.level_idx != 0 {
8829 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8830 }
8831 if self.l0_sub_level_id != 0 {
8832 #[allow(clippy::needless_borrow)]
8833 #[allow(clippy::needless_borrows_for_generic_args)]
8834 struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
8835 }
8836 if !self.removed_table_ids.is_empty() {
8837 struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8838 }
8839 if !self.inserted_table_infos.is_empty() {
8840 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
8841 }
8842 if self.vnode_partition_count != 0 {
8843 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8844 }
8845 if self.compaction_group_version_id != 0 {
8846 #[allow(clippy::needless_borrow)]
8847 #[allow(clippy::needless_borrows_for_generic_args)]
8848 struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
8849 }
8850 struct_ser.end()
8851 }
8852}
8853impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
8854 #[allow(deprecated)]
8855 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8856 where
8857 D: serde::Deserializer<'de>,
8858 {
8859 const FIELDS: &[&str] = &[
8860 "level_idx",
8861 "levelIdx",
8862 "l0_sub_level_id",
8863 "l0SubLevelId",
8864 "removed_table_ids",
8865 "removedTableIds",
8866 "inserted_table_infos",
8867 "insertedTableInfos",
8868 "vnode_partition_count",
8869 "vnodePartitionCount",
8870 "compaction_group_version_id",
8871 "compactionGroupVersionId",
8872 ];
8873
8874 #[allow(clippy::enum_variant_names)]
8875 enum GeneratedField {
8876 LevelIdx,
8877 L0SubLevelId,
8878 RemovedTableIds,
8879 InsertedTableInfos,
8880 VnodePartitionCount,
8881 CompactionGroupVersionId,
8882 }
8883 impl<'de> serde::Deserialize<'de> for GeneratedField {
8884 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8885 where
8886 D: serde::Deserializer<'de>,
8887 {
8888 struct GeneratedVisitor;
8889
8890 impl serde::de::Visitor<'_> for GeneratedVisitor {
8891 type Value = GeneratedField;
8892
8893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8894 write!(formatter, "expected one of: {:?}", &FIELDS)
8895 }
8896
8897 #[allow(unused_variables)]
8898 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8899 where
8900 E: serde::de::Error,
8901 {
8902 match value {
8903 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8904 "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
8905 "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
8906 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
8907 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8908 "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
8909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8910 }
8911 }
8912 }
8913 deserializer.deserialize_identifier(GeneratedVisitor)
8914 }
8915 }
8916 struct GeneratedVisitor;
8917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8918 type Value = IntraLevelDelta;
8919
8920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8921 formatter.write_str("struct hummock.IntraLevelDelta")
8922 }
8923
8924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
8925 where
8926 V: serde::de::MapAccess<'de>,
8927 {
8928 let mut level_idx__ = None;
8929 let mut l0_sub_level_id__ = None;
8930 let mut removed_table_ids__ = None;
8931 let mut inserted_table_infos__ = None;
8932 let mut vnode_partition_count__ = None;
8933 let mut compaction_group_version_id__ = None;
8934 while let Some(k) = map_.next_key()? {
8935 match k {
8936 GeneratedField::LevelIdx => {
8937 if level_idx__.is_some() {
8938 return Err(serde::de::Error::duplicate_field("levelIdx"));
8939 }
8940 level_idx__ =
8941 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8942 ;
8943 }
8944 GeneratedField::L0SubLevelId => {
8945 if l0_sub_level_id__.is_some() {
8946 return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
8947 }
8948 l0_sub_level_id__ =
8949 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8950 ;
8951 }
8952 GeneratedField::RemovedTableIds => {
8953 if removed_table_ids__.is_some() {
8954 return Err(serde::de::Error::duplicate_field("removedTableIds"));
8955 }
8956 removed_table_ids__ =
8957 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8958 .into_iter().map(|x| x.0).collect())
8959 ;
8960 }
8961 GeneratedField::InsertedTableInfos => {
8962 if inserted_table_infos__.is_some() {
8963 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
8964 }
8965 inserted_table_infos__ = Some(map_.next_value()?);
8966 }
8967 GeneratedField::VnodePartitionCount => {
8968 if vnode_partition_count__.is_some() {
8969 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
8970 }
8971 vnode_partition_count__ =
8972 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8973 ;
8974 }
8975 GeneratedField::CompactionGroupVersionId => {
8976 if compaction_group_version_id__.is_some() {
8977 return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
8978 }
8979 compaction_group_version_id__ =
8980 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8981 ;
8982 }
8983 }
8984 }
8985 Ok(IntraLevelDelta {
8986 level_idx: level_idx__.unwrap_or_default(),
8987 l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
8988 removed_table_ids: removed_table_ids__.unwrap_or_default(),
8989 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
8990 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
8991 compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
8992 })
8993 }
8994 }
8995 deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
8996 }
8997}
8998impl serde::Serialize for KeyRange {
8999 #[allow(deprecated)]
9000 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9001 where
9002 S: serde::Serializer,
9003 {
9004 use serde::ser::SerializeStruct;
9005 let mut len = 0;
9006 if !self.left.is_empty() {
9007 len += 1;
9008 }
9009 if !self.right.is_empty() {
9010 len += 1;
9011 }
9012 if self.right_exclusive {
9013 len += 1;
9014 }
9015 let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
9016 if !self.left.is_empty() {
9017 #[allow(clippy::needless_borrow)]
9018 #[allow(clippy::needless_borrows_for_generic_args)]
9019 struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
9020 }
9021 if !self.right.is_empty() {
9022 #[allow(clippy::needless_borrow)]
9023 #[allow(clippy::needless_borrows_for_generic_args)]
9024 struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
9025 }
9026 if self.right_exclusive {
9027 struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
9028 }
9029 struct_ser.end()
9030 }
9031}
9032impl<'de> serde::Deserialize<'de> for KeyRange {
9033 #[allow(deprecated)]
9034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9035 where
9036 D: serde::Deserializer<'de>,
9037 {
9038 const FIELDS: &[&str] = &[
9039 "left",
9040 "right",
9041 "right_exclusive",
9042 "rightExclusive",
9043 ];
9044
9045 #[allow(clippy::enum_variant_names)]
9046 enum GeneratedField {
9047 Left,
9048 Right,
9049 RightExclusive,
9050 }
9051 impl<'de> serde::Deserialize<'de> for GeneratedField {
9052 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9053 where
9054 D: serde::Deserializer<'de>,
9055 {
9056 struct GeneratedVisitor;
9057
9058 impl serde::de::Visitor<'_> for GeneratedVisitor {
9059 type Value = GeneratedField;
9060
9061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9062 write!(formatter, "expected one of: {:?}", &FIELDS)
9063 }
9064
9065 #[allow(unused_variables)]
9066 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9067 where
9068 E: serde::de::Error,
9069 {
9070 match value {
9071 "left" => Ok(GeneratedField::Left),
9072 "right" => Ok(GeneratedField::Right),
9073 "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
9074 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9075 }
9076 }
9077 }
9078 deserializer.deserialize_identifier(GeneratedVisitor)
9079 }
9080 }
9081 struct GeneratedVisitor;
9082 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9083 type Value = KeyRange;
9084
9085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9086 formatter.write_str("struct hummock.KeyRange")
9087 }
9088
9089 fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
9090 where
9091 V: serde::de::MapAccess<'de>,
9092 {
9093 let mut left__ = None;
9094 let mut right__ = None;
9095 let mut right_exclusive__ = None;
9096 while let Some(k) = map_.next_key()? {
9097 match k {
9098 GeneratedField::Left => {
9099 if left__.is_some() {
9100 return Err(serde::de::Error::duplicate_field("left"));
9101 }
9102 left__ =
9103 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
9104 ;
9105 }
9106 GeneratedField::Right => {
9107 if right__.is_some() {
9108 return Err(serde::de::Error::duplicate_field("right"));
9109 }
9110 right__ =
9111 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
9112 ;
9113 }
9114 GeneratedField::RightExclusive => {
9115 if right_exclusive__.is_some() {
9116 return Err(serde::de::Error::duplicate_field("rightExclusive"));
9117 }
9118 right_exclusive__ = Some(map_.next_value()?);
9119 }
9120 }
9121 }
9122 Ok(KeyRange {
9123 left: left__.unwrap_or_default(),
9124 right: right__.unwrap_or_default(),
9125 right_exclusive: right_exclusive__.unwrap_or_default(),
9126 })
9127 }
9128 }
9129 deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
9130 }
9131}
9132impl serde::Serialize for Level {
9133 #[allow(deprecated)]
9134 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9135 where
9136 S: serde::Serializer,
9137 {
9138 use serde::ser::SerializeStruct;
9139 let mut len = 0;
9140 if self.level_idx != 0 {
9141 len += 1;
9142 }
9143 if self.level_type != 0 {
9144 len += 1;
9145 }
9146 if !self.table_infos.is_empty() {
9147 len += 1;
9148 }
9149 if self.total_file_size != 0 {
9150 len += 1;
9151 }
9152 if self.sub_level_id != 0 {
9153 len += 1;
9154 }
9155 if self.uncompressed_file_size != 0 {
9156 len += 1;
9157 }
9158 if self.vnode_partition_count != 0 {
9159 len += 1;
9160 }
9161 let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
9162 if self.level_idx != 0 {
9163 struct_ser.serialize_field("levelIdx", &self.level_idx)?;
9164 }
9165 if self.level_type != 0 {
9166 let v = LevelType::try_from(self.level_type)
9167 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
9168 struct_ser.serialize_field("levelType", &v)?;
9169 }
9170 if !self.table_infos.is_empty() {
9171 struct_ser.serialize_field("tableInfos", &self.table_infos)?;
9172 }
9173 if self.total_file_size != 0 {
9174 #[allow(clippy::needless_borrow)]
9175 #[allow(clippy::needless_borrows_for_generic_args)]
9176 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9177 }
9178 if self.sub_level_id != 0 {
9179 #[allow(clippy::needless_borrow)]
9180 #[allow(clippy::needless_borrows_for_generic_args)]
9181 struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
9182 }
9183 if self.uncompressed_file_size != 0 {
9184 #[allow(clippy::needless_borrow)]
9185 #[allow(clippy::needless_borrows_for_generic_args)]
9186 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
9187 }
9188 if self.vnode_partition_count != 0 {
9189 struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
9190 }
9191 struct_ser.end()
9192 }
9193}
9194impl<'de> serde::Deserialize<'de> for Level {
9195 #[allow(deprecated)]
9196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9197 where
9198 D: serde::Deserializer<'de>,
9199 {
9200 const FIELDS: &[&str] = &[
9201 "level_idx",
9202 "levelIdx",
9203 "level_type",
9204 "levelType",
9205 "table_infos",
9206 "tableInfos",
9207 "total_file_size",
9208 "totalFileSize",
9209 "sub_level_id",
9210 "subLevelId",
9211 "uncompressed_file_size",
9212 "uncompressedFileSize",
9213 "vnode_partition_count",
9214 "vnodePartitionCount",
9215 ];
9216
9217 #[allow(clippy::enum_variant_names)]
9218 enum GeneratedField {
9219 LevelIdx,
9220 LevelType,
9221 TableInfos,
9222 TotalFileSize,
9223 SubLevelId,
9224 UncompressedFileSize,
9225 VnodePartitionCount,
9226 }
9227 impl<'de> serde::Deserialize<'de> for GeneratedField {
9228 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9229 where
9230 D: serde::Deserializer<'de>,
9231 {
9232 struct GeneratedVisitor;
9233
9234 impl serde::de::Visitor<'_> for GeneratedVisitor {
9235 type Value = GeneratedField;
9236
9237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9238 write!(formatter, "expected one of: {:?}", &FIELDS)
9239 }
9240
9241 #[allow(unused_variables)]
9242 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9243 where
9244 E: serde::de::Error,
9245 {
9246 match value {
9247 "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
9248 "levelType" | "level_type" => Ok(GeneratedField::LevelType),
9249 "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
9250 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9251 "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
9252 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
9253 "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
9254 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9255 }
9256 }
9257 }
9258 deserializer.deserialize_identifier(GeneratedVisitor)
9259 }
9260 }
9261 struct GeneratedVisitor;
9262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9263 type Value = Level;
9264
9265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9266 formatter.write_str("struct hummock.Level")
9267 }
9268
9269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
9270 where
9271 V: serde::de::MapAccess<'de>,
9272 {
9273 let mut level_idx__ = None;
9274 let mut level_type__ = None;
9275 let mut table_infos__ = None;
9276 let mut total_file_size__ = None;
9277 let mut sub_level_id__ = None;
9278 let mut uncompressed_file_size__ = None;
9279 let mut vnode_partition_count__ = None;
9280 while let Some(k) = map_.next_key()? {
9281 match k {
9282 GeneratedField::LevelIdx => {
9283 if level_idx__.is_some() {
9284 return Err(serde::de::Error::duplicate_field("levelIdx"));
9285 }
9286 level_idx__ =
9287 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9288 ;
9289 }
9290 GeneratedField::LevelType => {
9291 if level_type__.is_some() {
9292 return Err(serde::de::Error::duplicate_field("levelType"));
9293 }
9294 level_type__ = Some(map_.next_value::<LevelType>()? as i32);
9295 }
9296 GeneratedField::TableInfos => {
9297 if table_infos__.is_some() {
9298 return Err(serde::de::Error::duplicate_field("tableInfos"));
9299 }
9300 table_infos__ = Some(map_.next_value()?);
9301 }
9302 GeneratedField::TotalFileSize => {
9303 if total_file_size__.is_some() {
9304 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9305 }
9306 total_file_size__ =
9307 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9308 ;
9309 }
9310 GeneratedField::SubLevelId => {
9311 if sub_level_id__.is_some() {
9312 return Err(serde::de::Error::duplicate_field("subLevelId"));
9313 }
9314 sub_level_id__ =
9315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9316 ;
9317 }
9318 GeneratedField::UncompressedFileSize => {
9319 if uncompressed_file_size__.is_some() {
9320 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
9321 }
9322 uncompressed_file_size__ =
9323 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9324 ;
9325 }
9326 GeneratedField::VnodePartitionCount => {
9327 if vnode_partition_count__.is_some() {
9328 return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
9329 }
9330 vnode_partition_count__ =
9331 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9332 ;
9333 }
9334 }
9335 }
9336 Ok(Level {
9337 level_idx: level_idx__.unwrap_or_default(),
9338 level_type: level_type__.unwrap_or_default(),
9339 table_infos: table_infos__.unwrap_or_default(),
9340 total_file_size: total_file_size__.unwrap_or_default(),
9341 sub_level_id: sub_level_id__.unwrap_or_default(),
9342 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
9343 vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
9344 })
9345 }
9346 }
9347 deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
9348 }
9349}
9350impl serde::Serialize for LevelHandler {
9351 #[allow(deprecated)]
9352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9353 where
9354 S: serde::Serializer,
9355 {
9356 use serde::ser::SerializeStruct;
9357 let mut len = 0;
9358 if self.level != 0 {
9359 len += 1;
9360 }
9361 if !self.tasks.is_empty() {
9362 len += 1;
9363 }
9364 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
9365 if self.level != 0 {
9366 struct_ser.serialize_field("level", &self.level)?;
9367 }
9368 if !self.tasks.is_empty() {
9369 struct_ser.serialize_field("tasks", &self.tasks)?;
9370 }
9371 struct_ser.end()
9372 }
9373}
9374impl<'de> serde::Deserialize<'de> for LevelHandler {
9375 #[allow(deprecated)]
9376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9377 where
9378 D: serde::Deserializer<'de>,
9379 {
9380 const FIELDS: &[&str] = &[
9381 "level",
9382 "tasks",
9383 ];
9384
9385 #[allow(clippy::enum_variant_names)]
9386 enum GeneratedField {
9387 Level,
9388 Tasks,
9389 }
9390 impl<'de> serde::Deserialize<'de> for GeneratedField {
9391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9392 where
9393 D: serde::Deserializer<'de>,
9394 {
9395 struct GeneratedVisitor;
9396
9397 impl serde::de::Visitor<'_> for GeneratedVisitor {
9398 type Value = GeneratedField;
9399
9400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9401 write!(formatter, "expected one of: {:?}", &FIELDS)
9402 }
9403
9404 #[allow(unused_variables)]
9405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9406 where
9407 E: serde::de::Error,
9408 {
9409 match value {
9410 "level" => Ok(GeneratedField::Level),
9411 "tasks" => Ok(GeneratedField::Tasks),
9412 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9413 }
9414 }
9415 }
9416 deserializer.deserialize_identifier(GeneratedVisitor)
9417 }
9418 }
9419 struct GeneratedVisitor;
9420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9421 type Value = LevelHandler;
9422
9423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9424 formatter.write_str("struct hummock.LevelHandler")
9425 }
9426
9427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
9428 where
9429 V: serde::de::MapAccess<'de>,
9430 {
9431 let mut level__ = None;
9432 let mut tasks__ = None;
9433 while let Some(k) = map_.next_key()? {
9434 match k {
9435 GeneratedField::Level => {
9436 if level__.is_some() {
9437 return Err(serde::de::Error::duplicate_field("level"));
9438 }
9439 level__ =
9440 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9441 ;
9442 }
9443 GeneratedField::Tasks => {
9444 if tasks__.is_some() {
9445 return Err(serde::de::Error::duplicate_field("tasks"));
9446 }
9447 tasks__ = Some(map_.next_value()?);
9448 }
9449 }
9450 }
9451 Ok(LevelHandler {
9452 level: level__.unwrap_or_default(),
9453 tasks: tasks__.unwrap_or_default(),
9454 })
9455 }
9456 }
9457 deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
9458 }
9459}
9460impl serde::Serialize for level_handler::RunningCompactTask {
9461 #[allow(deprecated)]
9462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9463 where
9464 S: serde::Serializer,
9465 {
9466 use serde::ser::SerializeStruct;
9467 let mut len = 0;
9468 if self.task_id != 0 {
9469 len += 1;
9470 }
9471 if !self.ssts.is_empty() {
9472 len += 1;
9473 }
9474 if self.total_file_size != 0 {
9475 len += 1;
9476 }
9477 if self.target_level != 0 {
9478 len += 1;
9479 }
9480 let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
9481 if self.task_id != 0 {
9482 #[allow(clippy::needless_borrow)]
9483 #[allow(clippy::needless_borrows_for_generic_args)]
9484 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
9485 }
9486 if !self.ssts.is_empty() {
9487 struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
9488 }
9489 if self.total_file_size != 0 {
9490 #[allow(clippy::needless_borrow)]
9491 #[allow(clippy::needless_borrows_for_generic_args)]
9492 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9493 }
9494 if self.target_level != 0 {
9495 struct_ser.serialize_field("targetLevel", &self.target_level)?;
9496 }
9497 struct_ser.end()
9498 }
9499}
9500impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
9501 #[allow(deprecated)]
9502 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9503 where
9504 D: serde::Deserializer<'de>,
9505 {
9506 const FIELDS: &[&str] = &[
9507 "task_id",
9508 "taskId",
9509 "ssts",
9510 "total_file_size",
9511 "totalFileSize",
9512 "target_level",
9513 "targetLevel",
9514 ];
9515
9516 #[allow(clippy::enum_variant_names)]
9517 enum GeneratedField {
9518 TaskId,
9519 Ssts,
9520 TotalFileSize,
9521 TargetLevel,
9522 }
9523 impl<'de> serde::Deserialize<'de> for GeneratedField {
9524 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9525 where
9526 D: serde::Deserializer<'de>,
9527 {
9528 struct GeneratedVisitor;
9529
9530 impl serde::de::Visitor<'_> for GeneratedVisitor {
9531 type Value = GeneratedField;
9532
9533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9534 write!(formatter, "expected one of: {:?}", &FIELDS)
9535 }
9536
9537 #[allow(unused_variables)]
9538 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9539 where
9540 E: serde::de::Error,
9541 {
9542 match value {
9543 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
9544 "ssts" => Ok(GeneratedField::Ssts),
9545 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9546 "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
9547 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9548 }
9549 }
9550 }
9551 deserializer.deserialize_identifier(GeneratedVisitor)
9552 }
9553 }
9554 struct GeneratedVisitor;
9555 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9556 type Value = level_handler::RunningCompactTask;
9557
9558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9559 formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
9560 }
9561
9562 fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
9563 where
9564 V: serde::de::MapAccess<'de>,
9565 {
9566 let mut task_id__ = None;
9567 let mut ssts__ = None;
9568 let mut total_file_size__ = None;
9569 let mut target_level__ = None;
9570 while let Some(k) = map_.next_key()? {
9571 match k {
9572 GeneratedField::TaskId => {
9573 if task_id__.is_some() {
9574 return Err(serde::de::Error::duplicate_field("taskId"));
9575 }
9576 task_id__ =
9577 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9578 ;
9579 }
9580 GeneratedField::Ssts => {
9581 if ssts__.is_some() {
9582 return Err(serde::de::Error::duplicate_field("ssts"));
9583 }
9584 ssts__ =
9585 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9586 .into_iter().map(|x| x.0).collect())
9587 ;
9588 }
9589 GeneratedField::TotalFileSize => {
9590 if total_file_size__.is_some() {
9591 return Err(serde::de::Error::duplicate_field("totalFileSize"));
9592 }
9593 total_file_size__ =
9594 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9595 ;
9596 }
9597 GeneratedField::TargetLevel => {
9598 if target_level__.is_some() {
9599 return Err(serde::de::Error::duplicate_field("targetLevel"));
9600 }
9601 target_level__ =
9602 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9603 ;
9604 }
9605 }
9606 }
9607 Ok(level_handler::RunningCompactTask {
9608 task_id: task_id__.unwrap_or_default(),
9609 ssts: ssts__.unwrap_or_default(),
9610 total_file_size: total_file_size__.unwrap_or_default(),
9611 target_level: target_level__.unwrap_or_default(),
9612 })
9613 }
9614 }
9615 deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
9616 }
9617}
9618impl serde::Serialize for LevelType {
9619 #[allow(deprecated)]
9620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9621 where
9622 S: serde::Serializer,
9623 {
9624 let variant = match self {
9625 Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
9626 Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
9627 Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
9628 };
9629 serializer.serialize_str(variant)
9630 }
9631}
9632impl<'de> serde::Deserialize<'de> for LevelType {
9633 #[allow(deprecated)]
9634 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9635 where
9636 D: serde::Deserializer<'de>,
9637 {
9638 const FIELDS: &[&str] = &[
9639 "LEVEL_TYPE_UNSPECIFIED",
9640 "LEVEL_TYPE_NONOVERLAPPING",
9641 "LEVEL_TYPE_OVERLAPPING",
9642 ];
9643
9644 struct GeneratedVisitor;
9645
9646 impl serde::de::Visitor<'_> for GeneratedVisitor {
9647 type Value = LevelType;
9648
9649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9650 write!(formatter, "expected one of: {:?}", &FIELDS)
9651 }
9652
9653 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9654 where
9655 E: serde::de::Error,
9656 {
9657 i32::try_from(v)
9658 .ok()
9659 .and_then(|x| x.try_into().ok())
9660 .ok_or_else(|| {
9661 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9662 })
9663 }
9664
9665 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9666 where
9667 E: serde::de::Error,
9668 {
9669 i32::try_from(v)
9670 .ok()
9671 .and_then(|x| x.try_into().ok())
9672 .ok_or_else(|| {
9673 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9674 })
9675 }
9676
9677 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9678 where
9679 E: serde::de::Error,
9680 {
9681 match value {
9682 "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
9683 "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
9684 "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
9685 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9686 }
9687 }
9688 }
9689 deserializer.deserialize_any(GeneratedVisitor)
9690 }
9691}
9692impl serde::Serialize for ListActiveWriteLimitRequest {
9693 #[allow(deprecated)]
9694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9695 where
9696 S: serde::Serializer,
9697 {
9698 use serde::ser::SerializeStruct;
9699 let len = 0;
9700 let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
9701 struct_ser.end()
9702 }
9703}
9704impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
9705 #[allow(deprecated)]
9706 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9707 where
9708 D: serde::Deserializer<'de>,
9709 {
9710 const FIELDS: &[&str] = &[
9711 ];
9712
9713 #[allow(clippy::enum_variant_names)]
9714 enum GeneratedField {
9715 }
9716 impl<'de> serde::Deserialize<'de> for GeneratedField {
9717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9718 where
9719 D: serde::Deserializer<'de>,
9720 {
9721 struct GeneratedVisitor;
9722
9723 impl serde::de::Visitor<'_> for GeneratedVisitor {
9724 type Value = GeneratedField;
9725
9726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9727 write!(formatter, "expected one of: {:?}", &FIELDS)
9728 }
9729
9730 #[allow(unused_variables)]
9731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9732 where
9733 E: serde::de::Error,
9734 {
9735 Err(serde::de::Error::unknown_field(value, FIELDS))
9736 }
9737 }
9738 deserializer.deserialize_identifier(GeneratedVisitor)
9739 }
9740 }
9741 struct GeneratedVisitor;
9742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9743 type Value = ListActiveWriteLimitRequest;
9744
9745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9746 formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
9747 }
9748
9749 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
9750 where
9751 V: serde::de::MapAccess<'de>,
9752 {
9753 while map_.next_key::<GeneratedField>()?.is_some() {
9754 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9755 }
9756 Ok(ListActiveWriteLimitRequest {
9757 })
9758 }
9759 }
9760 deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
9761 }
9762}
9763impl serde::Serialize for ListActiveWriteLimitResponse {
9764 #[allow(deprecated)]
9765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9766 where
9767 S: serde::Serializer,
9768 {
9769 use serde::ser::SerializeStruct;
9770 let mut len = 0;
9771 if !self.write_limits.is_empty() {
9772 len += 1;
9773 }
9774 let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
9775 if !self.write_limits.is_empty() {
9776 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
9777 }
9778 struct_ser.end()
9779 }
9780}
9781impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
9782 #[allow(deprecated)]
9783 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9784 where
9785 D: serde::Deserializer<'de>,
9786 {
9787 const FIELDS: &[&str] = &[
9788 "write_limits",
9789 "writeLimits",
9790 ];
9791
9792 #[allow(clippy::enum_variant_names)]
9793 enum GeneratedField {
9794 WriteLimits,
9795 }
9796 impl<'de> serde::Deserialize<'de> for GeneratedField {
9797 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9798 where
9799 D: serde::Deserializer<'de>,
9800 {
9801 struct GeneratedVisitor;
9802
9803 impl serde::de::Visitor<'_> for GeneratedVisitor {
9804 type Value = GeneratedField;
9805
9806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9807 write!(formatter, "expected one of: {:?}", &FIELDS)
9808 }
9809
9810 #[allow(unused_variables)]
9811 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9812 where
9813 E: serde::de::Error,
9814 {
9815 match value {
9816 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
9817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9818 }
9819 }
9820 }
9821 deserializer.deserialize_identifier(GeneratedVisitor)
9822 }
9823 }
9824 struct GeneratedVisitor;
9825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9826 type Value = ListActiveWriteLimitResponse;
9827
9828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9829 formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
9830 }
9831
9832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
9833 where
9834 V: serde::de::MapAccess<'de>,
9835 {
9836 let mut write_limits__ = None;
9837 while let Some(k) = map_.next_key()? {
9838 match k {
9839 GeneratedField::WriteLimits => {
9840 if write_limits__.is_some() {
9841 return Err(serde::de::Error::duplicate_field("writeLimits"));
9842 }
9843 write_limits__ = Some(
9844 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
9845 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9846 );
9847 }
9848 }
9849 }
9850 Ok(ListActiveWriteLimitResponse {
9851 write_limits: write_limits__.unwrap_or_default(),
9852 })
9853 }
9854 }
9855 deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
9856 }
9857}
9858impl serde::Serialize for ListBranchedObjectRequest {
9859 #[allow(deprecated)]
9860 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9861 where
9862 S: serde::Serializer,
9863 {
9864 use serde::ser::SerializeStruct;
9865 let len = 0;
9866 let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
9867 struct_ser.end()
9868 }
9869}
9870impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
9871 #[allow(deprecated)]
9872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9873 where
9874 D: serde::Deserializer<'de>,
9875 {
9876 const FIELDS: &[&str] = &[
9877 ];
9878
9879 #[allow(clippy::enum_variant_names)]
9880 enum GeneratedField {
9881 }
9882 impl<'de> serde::Deserialize<'de> for GeneratedField {
9883 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9884 where
9885 D: serde::Deserializer<'de>,
9886 {
9887 struct GeneratedVisitor;
9888
9889 impl serde::de::Visitor<'_> for GeneratedVisitor {
9890 type Value = GeneratedField;
9891
9892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9893 write!(formatter, "expected one of: {:?}", &FIELDS)
9894 }
9895
9896 #[allow(unused_variables)]
9897 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9898 where
9899 E: serde::de::Error,
9900 {
9901 Err(serde::de::Error::unknown_field(value, FIELDS))
9902 }
9903 }
9904 deserializer.deserialize_identifier(GeneratedVisitor)
9905 }
9906 }
9907 struct GeneratedVisitor;
9908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9909 type Value = ListBranchedObjectRequest;
9910
9911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9912 formatter.write_str("struct hummock.ListBranchedObjectRequest")
9913 }
9914
9915 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
9916 where
9917 V: serde::de::MapAccess<'de>,
9918 {
9919 while map_.next_key::<GeneratedField>()?.is_some() {
9920 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9921 }
9922 Ok(ListBranchedObjectRequest {
9923 })
9924 }
9925 }
9926 deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
9927 }
9928}
9929impl serde::Serialize for ListBranchedObjectResponse {
9930 #[allow(deprecated)]
9931 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9932 where
9933 S: serde::Serializer,
9934 {
9935 use serde::ser::SerializeStruct;
9936 let mut len = 0;
9937 if !self.branched_objects.is_empty() {
9938 len += 1;
9939 }
9940 let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
9941 if !self.branched_objects.is_empty() {
9942 struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
9943 }
9944 struct_ser.end()
9945 }
9946}
9947impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
9948 #[allow(deprecated)]
9949 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9950 where
9951 D: serde::Deserializer<'de>,
9952 {
9953 const FIELDS: &[&str] = &[
9954 "branched_objects",
9955 "branchedObjects",
9956 ];
9957
9958 #[allow(clippy::enum_variant_names)]
9959 enum GeneratedField {
9960 BranchedObjects,
9961 }
9962 impl<'de> serde::Deserialize<'de> for GeneratedField {
9963 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9964 where
9965 D: serde::Deserializer<'de>,
9966 {
9967 struct GeneratedVisitor;
9968
9969 impl serde::de::Visitor<'_> for GeneratedVisitor {
9970 type Value = GeneratedField;
9971
9972 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9973 write!(formatter, "expected one of: {:?}", &FIELDS)
9974 }
9975
9976 #[allow(unused_variables)]
9977 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9978 where
9979 E: serde::de::Error,
9980 {
9981 match value {
9982 "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
9983 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9984 }
9985 }
9986 }
9987 deserializer.deserialize_identifier(GeneratedVisitor)
9988 }
9989 }
9990 struct GeneratedVisitor;
9991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9992 type Value = ListBranchedObjectResponse;
9993
9994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9995 formatter.write_str("struct hummock.ListBranchedObjectResponse")
9996 }
9997
9998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
9999 where
10000 V: serde::de::MapAccess<'de>,
10001 {
10002 let mut branched_objects__ = None;
10003 while let Some(k) = map_.next_key()? {
10004 match k {
10005 GeneratedField::BranchedObjects => {
10006 if branched_objects__.is_some() {
10007 return Err(serde::de::Error::duplicate_field("branchedObjects"));
10008 }
10009 branched_objects__ = Some(map_.next_value()?);
10010 }
10011 }
10012 }
10013 Ok(ListBranchedObjectResponse {
10014 branched_objects: branched_objects__.unwrap_or_default(),
10015 })
10016 }
10017 }
10018 deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
10019 }
10020}
10021impl serde::Serialize for ListCompactTaskAssignmentRequest {
10022 #[allow(deprecated)]
10023 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10024 where
10025 S: serde::Serializer,
10026 {
10027 use serde::ser::SerializeStruct;
10028 let len = 0;
10029 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
10030 struct_ser.end()
10031 }
10032}
10033impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
10034 #[allow(deprecated)]
10035 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10036 where
10037 D: serde::Deserializer<'de>,
10038 {
10039 const FIELDS: &[&str] = &[
10040 ];
10041
10042 #[allow(clippy::enum_variant_names)]
10043 enum GeneratedField {
10044 }
10045 impl<'de> serde::Deserialize<'de> for GeneratedField {
10046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10047 where
10048 D: serde::Deserializer<'de>,
10049 {
10050 struct GeneratedVisitor;
10051
10052 impl serde::de::Visitor<'_> for GeneratedVisitor {
10053 type Value = GeneratedField;
10054
10055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10056 write!(formatter, "expected one of: {:?}", &FIELDS)
10057 }
10058
10059 #[allow(unused_variables)]
10060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10061 where
10062 E: serde::de::Error,
10063 {
10064 Err(serde::de::Error::unknown_field(value, FIELDS))
10065 }
10066 }
10067 deserializer.deserialize_identifier(GeneratedVisitor)
10068 }
10069 }
10070 struct GeneratedVisitor;
10071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10072 type Value = ListCompactTaskAssignmentRequest;
10073
10074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10075 formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
10076 }
10077
10078 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
10079 where
10080 V: serde::de::MapAccess<'de>,
10081 {
10082 while map_.next_key::<GeneratedField>()?.is_some() {
10083 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10084 }
10085 Ok(ListCompactTaskAssignmentRequest {
10086 })
10087 }
10088 }
10089 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
10090 }
10091}
10092impl serde::Serialize for ListCompactTaskAssignmentResponse {
10093 #[allow(deprecated)]
10094 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10095 where
10096 S: serde::Serializer,
10097 {
10098 use serde::ser::SerializeStruct;
10099 let mut len = 0;
10100 if !self.task_assignment.is_empty() {
10101 len += 1;
10102 }
10103 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
10104 if !self.task_assignment.is_empty() {
10105 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
10106 }
10107 struct_ser.end()
10108 }
10109}
10110impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
10111 #[allow(deprecated)]
10112 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10113 where
10114 D: serde::Deserializer<'de>,
10115 {
10116 const FIELDS: &[&str] = &[
10117 "task_assignment",
10118 "taskAssignment",
10119 ];
10120
10121 #[allow(clippy::enum_variant_names)]
10122 enum GeneratedField {
10123 TaskAssignment,
10124 }
10125 impl<'de> serde::Deserialize<'de> for GeneratedField {
10126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10127 where
10128 D: serde::Deserializer<'de>,
10129 {
10130 struct GeneratedVisitor;
10131
10132 impl serde::de::Visitor<'_> for GeneratedVisitor {
10133 type Value = GeneratedField;
10134
10135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10136 write!(formatter, "expected one of: {:?}", &FIELDS)
10137 }
10138
10139 #[allow(unused_variables)]
10140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10141 where
10142 E: serde::de::Error,
10143 {
10144 match value {
10145 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
10146 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10147 }
10148 }
10149 }
10150 deserializer.deserialize_identifier(GeneratedVisitor)
10151 }
10152 }
10153 struct GeneratedVisitor;
10154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10155 type Value = ListCompactTaskAssignmentResponse;
10156
10157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10158 formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
10159 }
10160
10161 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
10162 where
10163 V: serde::de::MapAccess<'de>,
10164 {
10165 let mut task_assignment__ = None;
10166 while let Some(k) = map_.next_key()? {
10167 match k {
10168 GeneratedField::TaskAssignment => {
10169 if task_assignment__.is_some() {
10170 return Err(serde::de::Error::duplicate_field("taskAssignment"));
10171 }
10172 task_assignment__ = Some(map_.next_value()?);
10173 }
10174 }
10175 }
10176 Ok(ListCompactTaskAssignmentResponse {
10177 task_assignment: task_assignment__.unwrap_or_default(),
10178 })
10179 }
10180 }
10181 deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
10182 }
10183}
10184impl serde::Serialize for ListCompactTaskProgressRequest {
10185 #[allow(deprecated)]
10186 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10187 where
10188 S: serde::Serializer,
10189 {
10190 use serde::ser::SerializeStruct;
10191 let len = 0;
10192 let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
10193 struct_ser.end()
10194 }
10195}
10196impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
10197 #[allow(deprecated)]
10198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10199 where
10200 D: serde::Deserializer<'de>,
10201 {
10202 const FIELDS: &[&str] = &[
10203 ];
10204
10205 #[allow(clippy::enum_variant_names)]
10206 enum GeneratedField {
10207 }
10208 impl<'de> serde::Deserialize<'de> for GeneratedField {
10209 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10210 where
10211 D: serde::Deserializer<'de>,
10212 {
10213 struct GeneratedVisitor;
10214
10215 impl serde::de::Visitor<'_> for GeneratedVisitor {
10216 type Value = GeneratedField;
10217
10218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10219 write!(formatter, "expected one of: {:?}", &FIELDS)
10220 }
10221
10222 #[allow(unused_variables)]
10223 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10224 where
10225 E: serde::de::Error,
10226 {
10227 Err(serde::de::Error::unknown_field(value, FIELDS))
10228 }
10229 }
10230 deserializer.deserialize_identifier(GeneratedVisitor)
10231 }
10232 }
10233 struct GeneratedVisitor;
10234 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10235 type Value = ListCompactTaskProgressRequest;
10236
10237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10238 formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
10239 }
10240
10241 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
10242 where
10243 V: serde::de::MapAccess<'de>,
10244 {
10245 while map_.next_key::<GeneratedField>()?.is_some() {
10246 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10247 }
10248 Ok(ListCompactTaskProgressRequest {
10249 })
10250 }
10251 }
10252 deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
10253 }
10254}
10255impl serde::Serialize for ListCompactTaskProgressResponse {
10256 #[allow(deprecated)]
10257 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10258 where
10259 S: serde::Serializer,
10260 {
10261 use serde::ser::SerializeStruct;
10262 let mut len = 0;
10263 if !self.task_progress.is_empty() {
10264 len += 1;
10265 }
10266 let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
10267 if !self.task_progress.is_empty() {
10268 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
10269 }
10270 struct_ser.end()
10271 }
10272}
10273impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
10274 #[allow(deprecated)]
10275 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10276 where
10277 D: serde::Deserializer<'de>,
10278 {
10279 const FIELDS: &[&str] = &[
10280 "task_progress",
10281 "taskProgress",
10282 ];
10283
10284 #[allow(clippy::enum_variant_names)]
10285 enum GeneratedField {
10286 TaskProgress,
10287 }
10288 impl<'de> serde::Deserialize<'de> for GeneratedField {
10289 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10290 where
10291 D: serde::Deserializer<'de>,
10292 {
10293 struct GeneratedVisitor;
10294
10295 impl serde::de::Visitor<'_> for GeneratedVisitor {
10296 type Value = GeneratedField;
10297
10298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10299 write!(formatter, "expected one of: {:?}", &FIELDS)
10300 }
10301
10302 #[allow(unused_variables)]
10303 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10304 where
10305 E: serde::de::Error,
10306 {
10307 match value {
10308 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
10309 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10310 }
10311 }
10312 }
10313 deserializer.deserialize_identifier(GeneratedVisitor)
10314 }
10315 }
10316 struct GeneratedVisitor;
10317 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10318 type Value = ListCompactTaskProgressResponse;
10319
10320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10321 formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
10322 }
10323
10324 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
10325 where
10326 V: serde::de::MapAccess<'de>,
10327 {
10328 let mut task_progress__ = None;
10329 while let Some(k) = map_.next_key()? {
10330 match k {
10331 GeneratedField::TaskProgress => {
10332 if task_progress__.is_some() {
10333 return Err(serde::de::Error::duplicate_field("taskProgress"));
10334 }
10335 task_progress__ = Some(map_.next_value()?);
10336 }
10337 }
10338 }
10339 Ok(ListCompactTaskProgressResponse {
10340 task_progress: task_progress__.unwrap_or_default(),
10341 })
10342 }
10343 }
10344 deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
10345 }
10346}
10347impl serde::Serialize for ListHummockMetaConfigRequest {
10348 #[allow(deprecated)]
10349 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10350 where
10351 S: serde::Serializer,
10352 {
10353 use serde::ser::SerializeStruct;
10354 let len = 0;
10355 let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
10356 struct_ser.end()
10357 }
10358}
10359impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
10360 #[allow(deprecated)]
10361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10362 where
10363 D: serde::Deserializer<'de>,
10364 {
10365 const FIELDS: &[&str] = &[
10366 ];
10367
10368 #[allow(clippy::enum_variant_names)]
10369 enum GeneratedField {
10370 }
10371 impl<'de> serde::Deserialize<'de> for GeneratedField {
10372 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10373 where
10374 D: serde::Deserializer<'de>,
10375 {
10376 struct GeneratedVisitor;
10377
10378 impl serde::de::Visitor<'_> for GeneratedVisitor {
10379 type Value = GeneratedField;
10380
10381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10382 write!(formatter, "expected one of: {:?}", &FIELDS)
10383 }
10384
10385 #[allow(unused_variables)]
10386 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10387 where
10388 E: serde::de::Error,
10389 {
10390 Err(serde::de::Error::unknown_field(value, FIELDS))
10391 }
10392 }
10393 deserializer.deserialize_identifier(GeneratedVisitor)
10394 }
10395 }
10396 struct GeneratedVisitor;
10397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10398 type Value = ListHummockMetaConfigRequest;
10399
10400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10401 formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
10402 }
10403
10404 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
10405 where
10406 V: serde::de::MapAccess<'de>,
10407 {
10408 while map_.next_key::<GeneratedField>()?.is_some() {
10409 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10410 }
10411 Ok(ListHummockMetaConfigRequest {
10412 })
10413 }
10414 }
10415 deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
10416 }
10417}
10418impl serde::Serialize for ListHummockMetaConfigResponse {
10419 #[allow(deprecated)]
10420 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10421 where
10422 S: serde::Serializer,
10423 {
10424 use serde::ser::SerializeStruct;
10425 let mut len = 0;
10426 if !self.configs.is_empty() {
10427 len += 1;
10428 }
10429 let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
10430 if !self.configs.is_empty() {
10431 struct_ser.serialize_field("configs", &self.configs)?;
10432 }
10433 struct_ser.end()
10434 }
10435}
10436impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
10437 #[allow(deprecated)]
10438 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10439 where
10440 D: serde::Deserializer<'de>,
10441 {
10442 const FIELDS: &[&str] = &[
10443 "configs",
10444 ];
10445
10446 #[allow(clippy::enum_variant_names)]
10447 enum GeneratedField {
10448 Configs,
10449 }
10450 impl<'de> serde::Deserialize<'de> for GeneratedField {
10451 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10452 where
10453 D: serde::Deserializer<'de>,
10454 {
10455 struct GeneratedVisitor;
10456
10457 impl serde::de::Visitor<'_> for GeneratedVisitor {
10458 type Value = GeneratedField;
10459
10460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10461 write!(formatter, "expected one of: {:?}", &FIELDS)
10462 }
10463
10464 #[allow(unused_variables)]
10465 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10466 where
10467 E: serde::de::Error,
10468 {
10469 match value {
10470 "configs" => Ok(GeneratedField::Configs),
10471 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10472 }
10473 }
10474 }
10475 deserializer.deserialize_identifier(GeneratedVisitor)
10476 }
10477 }
10478 struct GeneratedVisitor;
10479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10480 type Value = ListHummockMetaConfigResponse;
10481
10482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10483 formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
10484 }
10485
10486 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
10487 where
10488 V: serde::de::MapAccess<'de>,
10489 {
10490 let mut configs__ = None;
10491 while let Some(k) = map_.next_key()? {
10492 match k {
10493 GeneratedField::Configs => {
10494 if configs__.is_some() {
10495 return Err(serde::de::Error::duplicate_field("configs"));
10496 }
10497 configs__ = Some(
10498 map_.next_value::<std::collections::HashMap<_, _>>()?
10499 );
10500 }
10501 }
10502 }
10503 Ok(ListHummockMetaConfigResponse {
10504 configs: configs__.unwrap_or_default(),
10505 })
10506 }
10507 }
10508 deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
10509 }
10510}
10511impl serde::Serialize for ListVersionDeltasRequest {
10512 #[allow(deprecated)]
10513 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10514 where
10515 S: serde::Serializer,
10516 {
10517 use serde::ser::SerializeStruct;
10518 let mut len = 0;
10519 if self.start_id != 0 {
10520 len += 1;
10521 }
10522 if self.num_limit != 0 {
10523 len += 1;
10524 }
10525 if self.committed_epoch_limit != 0 {
10526 len += 1;
10527 }
10528 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
10529 if self.start_id != 0 {
10530 #[allow(clippy::needless_borrow)]
10531 #[allow(clippy::needless_borrows_for_generic_args)]
10532 struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
10533 }
10534 if self.num_limit != 0 {
10535 struct_ser.serialize_field("numLimit", &self.num_limit)?;
10536 }
10537 if self.committed_epoch_limit != 0 {
10538 #[allow(clippy::needless_borrow)]
10539 #[allow(clippy::needless_borrows_for_generic_args)]
10540 struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
10541 }
10542 struct_ser.end()
10543 }
10544}
10545impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
10546 #[allow(deprecated)]
10547 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10548 where
10549 D: serde::Deserializer<'de>,
10550 {
10551 const FIELDS: &[&str] = &[
10552 "start_id",
10553 "startId",
10554 "num_limit",
10555 "numLimit",
10556 "committed_epoch_limit",
10557 "committedEpochLimit",
10558 ];
10559
10560 #[allow(clippy::enum_variant_names)]
10561 enum GeneratedField {
10562 StartId,
10563 NumLimit,
10564 CommittedEpochLimit,
10565 }
10566 impl<'de> serde::Deserialize<'de> for GeneratedField {
10567 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10568 where
10569 D: serde::Deserializer<'de>,
10570 {
10571 struct GeneratedVisitor;
10572
10573 impl serde::de::Visitor<'_> for GeneratedVisitor {
10574 type Value = GeneratedField;
10575
10576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10577 write!(formatter, "expected one of: {:?}", &FIELDS)
10578 }
10579
10580 #[allow(unused_variables)]
10581 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10582 where
10583 E: serde::de::Error,
10584 {
10585 match value {
10586 "startId" | "start_id" => Ok(GeneratedField::StartId),
10587 "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
10588 "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
10589 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10590 }
10591 }
10592 }
10593 deserializer.deserialize_identifier(GeneratedVisitor)
10594 }
10595 }
10596 struct GeneratedVisitor;
10597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10598 type Value = ListVersionDeltasRequest;
10599
10600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10601 formatter.write_str("struct hummock.ListVersionDeltasRequest")
10602 }
10603
10604 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
10605 where
10606 V: serde::de::MapAccess<'de>,
10607 {
10608 let mut start_id__ = None;
10609 let mut num_limit__ = None;
10610 let mut committed_epoch_limit__ = None;
10611 while let Some(k) = map_.next_key()? {
10612 match k {
10613 GeneratedField::StartId => {
10614 if start_id__.is_some() {
10615 return Err(serde::de::Error::duplicate_field("startId"));
10616 }
10617 start_id__ =
10618 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10619 ;
10620 }
10621 GeneratedField::NumLimit => {
10622 if num_limit__.is_some() {
10623 return Err(serde::de::Error::duplicate_field("numLimit"));
10624 }
10625 num_limit__ =
10626 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10627 ;
10628 }
10629 GeneratedField::CommittedEpochLimit => {
10630 if committed_epoch_limit__.is_some() {
10631 return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
10632 }
10633 committed_epoch_limit__ =
10634 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10635 ;
10636 }
10637 }
10638 }
10639 Ok(ListVersionDeltasRequest {
10640 start_id: start_id__.unwrap_or_default(),
10641 num_limit: num_limit__.unwrap_or_default(),
10642 committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
10643 })
10644 }
10645 }
10646 deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
10647 }
10648}
10649impl serde::Serialize for ListVersionDeltasResponse {
10650 #[allow(deprecated)]
10651 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10652 where
10653 S: serde::Serializer,
10654 {
10655 use serde::ser::SerializeStruct;
10656 let mut len = 0;
10657 if self.version_deltas.is_some() {
10658 len += 1;
10659 }
10660 let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
10661 if let Some(v) = self.version_deltas.as_ref() {
10662 struct_ser.serialize_field("versionDeltas", v)?;
10663 }
10664 struct_ser.end()
10665 }
10666}
10667impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
10668 #[allow(deprecated)]
10669 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10670 where
10671 D: serde::Deserializer<'de>,
10672 {
10673 const FIELDS: &[&str] = &[
10674 "version_deltas",
10675 "versionDeltas",
10676 ];
10677
10678 #[allow(clippy::enum_variant_names)]
10679 enum GeneratedField {
10680 VersionDeltas,
10681 }
10682 impl<'de> serde::Deserialize<'de> for GeneratedField {
10683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10684 where
10685 D: serde::Deserializer<'de>,
10686 {
10687 struct GeneratedVisitor;
10688
10689 impl serde::de::Visitor<'_> for GeneratedVisitor {
10690 type Value = GeneratedField;
10691
10692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10693 write!(formatter, "expected one of: {:?}", &FIELDS)
10694 }
10695
10696 #[allow(unused_variables)]
10697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10698 where
10699 E: serde::de::Error,
10700 {
10701 match value {
10702 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
10703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10704 }
10705 }
10706 }
10707 deserializer.deserialize_identifier(GeneratedVisitor)
10708 }
10709 }
10710 struct GeneratedVisitor;
10711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10712 type Value = ListVersionDeltasResponse;
10713
10714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10715 formatter.write_str("struct hummock.ListVersionDeltasResponse")
10716 }
10717
10718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
10719 where
10720 V: serde::de::MapAccess<'de>,
10721 {
10722 let mut version_deltas__ = None;
10723 while let Some(k) = map_.next_key()? {
10724 match k {
10725 GeneratedField::VersionDeltas => {
10726 if version_deltas__.is_some() {
10727 return Err(serde::de::Error::duplicate_field("versionDeltas"));
10728 }
10729 version_deltas__ = map_.next_value()?;
10730 }
10731 }
10732 }
10733 Ok(ListVersionDeltasResponse {
10734 version_deltas: version_deltas__,
10735 })
10736 }
10737 }
10738 deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
10739 }
10740}
10741impl serde::Serialize for MergeCompactionGroupRequest {
10742 #[allow(deprecated)]
10743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10744 where
10745 S: serde::Serializer,
10746 {
10747 use serde::ser::SerializeStruct;
10748 let mut len = 0;
10749 if self.left_group_id != 0 {
10750 len += 1;
10751 }
10752 if self.right_group_id != 0 {
10753 len += 1;
10754 }
10755 let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
10756 if self.left_group_id != 0 {
10757 #[allow(clippy::needless_borrow)]
10758 #[allow(clippy::needless_borrows_for_generic_args)]
10759 struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
10760 }
10761 if self.right_group_id != 0 {
10762 #[allow(clippy::needless_borrow)]
10763 #[allow(clippy::needless_borrows_for_generic_args)]
10764 struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
10765 }
10766 struct_ser.end()
10767 }
10768}
10769impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
10770 #[allow(deprecated)]
10771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10772 where
10773 D: serde::Deserializer<'de>,
10774 {
10775 const FIELDS: &[&str] = &[
10776 "left_group_id",
10777 "leftGroupId",
10778 "right_group_id",
10779 "rightGroupId",
10780 ];
10781
10782 #[allow(clippy::enum_variant_names)]
10783 enum GeneratedField {
10784 LeftGroupId,
10785 RightGroupId,
10786 }
10787 impl<'de> serde::Deserialize<'de> for GeneratedField {
10788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10789 where
10790 D: serde::Deserializer<'de>,
10791 {
10792 struct GeneratedVisitor;
10793
10794 impl serde::de::Visitor<'_> for GeneratedVisitor {
10795 type Value = GeneratedField;
10796
10797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10798 write!(formatter, "expected one of: {:?}", &FIELDS)
10799 }
10800
10801 #[allow(unused_variables)]
10802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10803 where
10804 E: serde::de::Error,
10805 {
10806 match value {
10807 "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
10808 "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
10809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10810 }
10811 }
10812 }
10813 deserializer.deserialize_identifier(GeneratedVisitor)
10814 }
10815 }
10816 struct GeneratedVisitor;
10817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10818 type Value = MergeCompactionGroupRequest;
10819
10820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10821 formatter.write_str("struct hummock.MergeCompactionGroupRequest")
10822 }
10823
10824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
10825 where
10826 V: serde::de::MapAccess<'de>,
10827 {
10828 let mut left_group_id__ = None;
10829 let mut right_group_id__ = None;
10830 while let Some(k) = map_.next_key()? {
10831 match k {
10832 GeneratedField::LeftGroupId => {
10833 if left_group_id__.is_some() {
10834 return Err(serde::de::Error::duplicate_field("leftGroupId"));
10835 }
10836 left_group_id__ =
10837 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10838 ;
10839 }
10840 GeneratedField::RightGroupId => {
10841 if right_group_id__.is_some() {
10842 return Err(serde::de::Error::duplicate_field("rightGroupId"));
10843 }
10844 right_group_id__ =
10845 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10846 ;
10847 }
10848 }
10849 }
10850 Ok(MergeCompactionGroupRequest {
10851 left_group_id: left_group_id__.unwrap_or_default(),
10852 right_group_id: right_group_id__.unwrap_or_default(),
10853 })
10854 }
10855 }
10856 deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
10857 }
10858}
10859impl serde::Serialize for MergeCompactionGroupResponse {
10860 #[allow(deprecated)]
10861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10862 where
10863 S: serde::Serializer,
10864 {
10865 use serde::ser::SerializeStruct;
10866 let len = 0;
10867 let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
10868 struct_ser.end()
10869 }
10870}
10871impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
10872 #[allow(deprecated)]
10873 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10874 where
10875 D: serde::Deserializer<'de>,
10876 {
10877 const FIELDS: &[&str] = &[
10878 ];
10879
10880 #[allow(clippy::enum_variant_names)]
10881 enum GeneratedField {
10882 }
10883 impl<'de> serde::Deserialize<'de> for GeneratedField {
10884 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10885 where
10886 D: serde::Deserializer<'de>,
10887 {
10888 struct GeneratedVisitor;
10889
10890 impl serde::de::Visitor<'_> for GeneratedVisitor {
10891 type Value = GeneratedField;
10892
10893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10894 write!(formatter, "expected one of: {:?}", &FIELDS)
10895 }
10896
10897 #[allow(unused_variables)]
10898 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10899 where
10900 E: serde::de::Error,
10901 {
10902 Err(serde::de::Error::unknown_field(value, FIELDS))
10903 }
10904 }
10905 deserializer.deserialize_identifier(GeneratedVisitor)
10906 }
10907 }
10908 struct GeneratedVisitor;
10909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10910 type Value = MergeCompactionGroupResponse;
10911
10912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10913 formatter.write_str("struct hummock.MergeCompactionGroupResponse")
10914 }
10915
10916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
10917 where
10918 V: serde::de::MapAccess<'de>,
10919 {
10920 while map_.next_key::<GeneratedField>()?.is_some() {
10921 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10922 }
10923 Ok(MergeCompactionGroupResponse {
10924 })
10925 }
10926 }
10927 deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
10928 }
10929}
10930impl serde::Serialize for NewL0SubLevel {
10931 #[allow(deprecated)]
10932 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10933 where
10934 S: serde::Serializer,
10935 {
10936 use serde::ser::SerializeStruct;
10937 let mut len = 0;
10938 if !self.inserted_table_infos.is_empty() {
10939 len += 1;
10940 }
10941 let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
10942 if !self.inserted_table_infos.is_empty() {
10943 struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
10944 }
10945 struct_ser.end()
10946 }
10947}
10948impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
10949 #[allow(deprecated)]
10950 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10951 where
10952 D: serde::Deserializer<'de>,
10953 {
10954 const FIELDS: &[&str] = &[
10955 "inserted_table_infos",
10956 "insertedTableInfos",
10957 ];
10958
10959 #[allow(clippy::enum_variant_names)]
10960 enum GeneratedField {
10961 InsertedTableInfos,
10962 }
10963 impl<'de> serde::Deserialize<'de> for GeneratedField {
10964 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10965 where
10966 D: serde::Deserializer<'de>,
10967 {
10968 struct GeneratedVisitor;
10969
10970 impl serde::de::Visitor<'_> for GeneratedVisitor {
10971 type Value = GeneratedField;
10972
10973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10974 write!(formatter, "expected one of: {:?}", &FIELDS)
10975 }
10976
10977 #[allow(unused_variables)]
10978 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10979 where
10980 E: serde::de::Error,
10981 {
10982 match value {
10983 "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
10984 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10985 }
10986 }
10987 }
10988 deserializer.deserialize_identifier(GeneratedVisitor)
10989 }
10990 }
10991 struct GeneratedVisitor;
10992 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10993 type Value = NewL0SubLevel;
10994
10995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10996 formatter.write_str("struct hummock.NewL0SubLevel")
10997 }
10998
10999 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
11000 where
11001 V: serde::de::MapAccess<'de>,
11002 {
11003 let mut inserted_table_infos__ = None;
11004 while let Some(k) = map_.next_key()? {
11005 match k {
11006 GeneratedField::InsertedTableInfos => {
11007 if inserted_table_infos__.is_some() {
11008 return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
11009 }
11010 inserted_table_infos__ = Some(map_.next_value()?);
11011 }
11012 }
11013 }
11014 Ok(NewL0SubLevel {
11015 inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
11016 })
11017 }
11018 }
11019 deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
11020 }
11021}
11022impl serde::Serialize for OverlappingLevel {
11023 #[allow(deprecated)]
11024 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11025 where
11026 S: serde::Serializer,
11027 {
11028 use serde::ser::SerializeStruct;
11029 let mut len = 0;
11030 if !self.sub_levels.is_empty() {
11031 len += 1;
11032 }
11033 if self.total_file_size != 0 {
11034 len += 1;
11035 }
11036 if self.uncompressed_file_size != 0 {
11037 len += 1;
11038 }
11039 let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
11040 if !self.sub_levels.is_empty() {
11041 struct_ser.serialize_field("subLevels", &self.sub_levels)?;
11042 }
11043 if self.total_file_size != 0 {
11044 #[allow(clippy::needless_borrow)]
11045 #[allow(clippy::needless_borrows_for_generic_args)]
11046 struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
11047 }
11048 if self.uncompressed_file_size != 0 {
11049 #[allow(clippy::needless_borrow)]
11050 #[allow(clippy::needless_borrows_for_generic_args)]
11051 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
11052 }
11053 struct_ser.end()
11054 }
11055}
11056impl<'de> serde::Deserialize<'de> for OverlappingLevel {
11057 #[allow(deprecated)]
11058 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11059 where
11060 D: serde::Deserializer<'de>,
11061 {
11062 const FIELDS: &[&str] = &[
11063 "sub_levels",
11064 "subLevels",
11065 "total_file_size",
11066 "totalFileSize",
11067 "uncompressed_file_size",
11068 "uncompressedFileSize",
11069 ];
11070
11071 #[allow(clippy::enum_variant_names)]
11072 enum GeneratedField {
11073 SubLevels,
11074 TotalFileSize,
11075 UncompressedFileSize,
11076 }
11077 impl<'de> serde::Deserialize<'de> for GeneratedField {
11078 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11079 where
11080 D: serde::Deserializer<'de>,
11081 {
11082 struct GeneratedVisitor;
11083
11084 impl serde::de::Visitor<'_> for GeneratedVisitor {
11085 type Value = GeneratedField;
11086
11087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11088 write!(formatter, "expected one of: {:?}", &FIELDS)
11089 }
11090
11091 #[allow(unused_variables)]
11092 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11093 where
11094 E: serde::de::Error,
11095 {
11096 match value {
11097 "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
11098 "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
11099 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
11100 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11101 }
11102 }
11103 }
11104 deserializer.deserialize_identifier(GeneratedVisitor)
11105 }
11106 }
11107 struct GeneratedVisitor;
11108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11109 type Value = OverlappingLevel;
11110
11111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11112 formatter.write_str("struct hummock.OverlappingLevel")
11113 }
11114
11115 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
11116 where
11117 V: serde::de::MapAccess<'de>,
11118 {
11119 let mut sub_levels__ = None;
11120 let mut total_file_size__ = None;
11121 let mut uncompressed_file_size__ = None;
11122 while let Some(k) = map_.next_key()? {
11123 match k {
11124 GeneratedField::SubLevels => {
11125 if sub_levels__.is_some() {
11126 return Err(serde::de::Error::duplicate_field("subLevels"));
11127 }
11128 sub_levels__ = Some(map_.next_value()?);
11129 }
11130 GeneratedField::TotalFileSize => {
11131 if total_file_size__.is_some() {
11132 return Err(serde::de::Error::duplicate_field("totalFileSize"));
11133 }
11134 total_file_size__ =
11135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11136 ;
11137 }
11138 GeneratedField::UncompressedFileSize => {
11139 if uncompressed_file_size__.is_some() {
11140 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
11141 }
11142 uncompressed_file_size__ =
11143 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11144 ;
11145 }
11146 }
11147 }
11148 Ok(OverlappingLevel {
11149 sub_levels: sub_levels__.unwrap_or_default(),
11150 total_file_size: total_file_size__.unwrap_or_default(),
11151 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
11152 })
11153 }
11154 }
11155 deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
11156 }
11157}
11158impl serde::Serialize for PinVersionRequest {
11159 #[allow(deprecated)]
11160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11161 where
11162 S: serde::Serializer,
11163 {
11164 use serde::ser::SerializeStruct;
11165 let mut len = 0;
11166 if self.context_id != 0 {
11167 len += 1;
11168 }
11169 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
11170 if self.context_id != 0 {
11171 struct_ser.serialize_field("contextId", &self.context_id)?;
11172 }
11173 struct_ser.end()
11174 }
11175}
11176impl<'de> serde::Deserialize<'de> for PinVersionRequest {
11177 #[allow(deprecated)]
11178 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11179 where
11180 D: serde::Deserializer<'de>,
11181 {
11182 const FIELDS: &[&str] = &[
11183 "context_id",
11184 "contextId",
11185 ];
11186
11187 #[allow(clippy::enum_variant_names)]
11188 enum GeneratedField {
11189 ContextId,
11190 }
11191 impl<'de> serde::Deserialize<'de> for GeneratedField {
11192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11193 where
11194 D: serde::Deserializer<'de>,
11195 {
11196 struct GeneratedVisitor;
11197
11198 impl serde::de::Visitor<'_> for GeneratedVisitor {
11199 type Value = GeneratedField;
11200
11201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11202 write!(formatter, "expected one of: {:?}", &FIELDS)
11203 }
11204
11205 #[allow(unused_variables)]
11206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11207 where
11208 E: serde::de::Error,
11209 {
11210 match value {
11211 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
11212 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11213 }
11214 }
11215 }
11216 deserializer.deserialize_identifier(GeneratedVisitor)
11217 }
11218 }
11219 struct GeneratedVisitor;
11220 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11221 type Value = PinVersionRequest;
11222
11223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11224 formatter.write_str("struct hummock.PinVersionRequest")
11225 }
11226
11227 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
11228 where
11229 V: serde::de::MapAccess<'de>,
11230 {
11231 let mut context_id__ = None;
11232 while let Some(k) = map_.next_key()? {
11233 match k {
11234 GeneratedField::ContextId => {
11235 if context_id__.is_some() {
11236 return Err(serde::de::Error::duplicate_field("contextId"));
11237 }
11238 context_id__ =
11239 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11240 ;
11241 }
11242 }
11243 }
11244 Ok(PinVersionRequest {
11245 context_id: context_id__.unwrap_or_default(),
11246 })
11247 }
11248 }
11249 deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
11250 }
11251}
11252impl serde::Serialize for PinVersionResponse {
11253 #[allow(deprecated)]
11254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11255 where
11256 S: serde::Serializer,
11257 {
11258 use serde::ser::SerializeStruct;
11259 let mut len = 0;
11260 if self.pinned_version.is_some() {
11261 len += 1;
11262 }
11263 let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
11264 if let Some(v) = self.pinned_version.as_ref() {
11265 struct_ser.serialize_field("pinnedVersion", v)?;
11266 }
11267 struct_ser.end()
11268 }
11269}
11270impl<'de> serde::Deserialize<'de> for PinVersionResponse {
11271 #[allow(deprecated)]
11272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11273 where
11274 D: serde::Deserializer<'de>,
11275 {
11276 const FIELDS: &[&str] = &[
11277 "pinned_version",
11278 "pinnedVersion",
11279 ];
11280
11281 #[allow(clippy::enum_variant_names)]
11282 enum GeneratedField {
11283 PinnedVersion,
11284 }
11285 impl<'de> serde::Deserialize<'de> for GeneratedField {
11286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11287 where
11288 D: serde::Deserializer<'de>,
11289 {
11290 struct GeneratedVisitor;
11291
11292 impl serde::de::Visitor<'_> for GeneratedVisitor {
11293 type Value = GeneratedField;
11294
11295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11296 write!(formatter, "expected one of: {:?}", &FIELDS)
11297 }
11298
11299 #[allow(unused_variables)]
11300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11301 where
11302 E: serde::de::Error,
11303 {
11304 match value {
11305 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
11306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11307 }
11308 }
11309 }
11310 deserializer.deserialize_identifier(GeneratedVisitor)
11311 }
11312 }
11313 struct GeneratedVisitor;
11314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11315 type Value = PinVersionResponse;
11316
11317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11318 formatter.write_str("struct hummock.PinVersionResponse")
11319 }
11320
11321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
11322 where
11323 V: serde::de::MapAccess<'de>,
11324 {
11325 let mut pinned_version__ = None;
11326 while let Some(k) = map_.next_key()? {
11327 match k {
11328 GeneratedField::PinnedVersion => {
11329 if pinned_version__.is_some() {
11330 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
11331 }
11332 pinned_version__ = map_.next_value()?;
11333 }
11334 }
11335 }
11336 Ok(PinVersionResponse {
11337 pinned_version: pinned_version__,
11338 })
11339 }
11340 }
11341 deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
11342 }
11343}
11344impl serde::Serialize for PinnedVersionsSummary {
11345 #[allow(deprecated)]
11346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11347 where
11348 S: serde::Serializer,
11349 {
11350 use serde::ser::SerializeStruct;
11351 let mut len = 0;
11352 if !self.pinned_versions.is_empty() {
11353 len += 1;
11354 }
11355 if !self.workers.is_empty() {
11356 len += 1;
11357 }
11358 let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
11359 if !self.pinned_versions.is_empty() {
11360 struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
11361 }
11362 if !self.workers.is_empty() {
11363 struct_ser.serialize_field("workers", &self.workers)?;
11364 }
11365 struct_ser.end()
11366 }
11367}
11368impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
11369 #[allow(deprecated)]
11370 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11371 where
11372 D: serde::Deserializer<'de>,
11373 {
11374 const FIELDS: &[&str] = &[
11375 "pinned_versions",
11376 "pinnedVersions",
11377 "workers",
11378 ];
11379
11380 #[allow(clippy::enum_variant_names)]
11381 enum GeneratedField {
11382 PinnedVersions,
11383 Workers,
11384 }
11385 impl<'de> serde::Deserialize<'de> for GeneratedField {
11386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11387 where
11388 D: serde::Deserializer<'de>,
11389 {
11390 struct GeneratedVisitor;
11391
11392 impl serde::de::Visitor<'_> for GeneratedVisitor {
11393 type Value = GeneratedField;
11394
11395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11396 write!(formatter, "expected one of: {:?}", &FIELDS)
11397 }
11398
11399 #[allow(unused_variables)]
11400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11401 where
11402 E: serde::de::Error,
11403 {
11404 match value {
11405 "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
11406 "workers" => Ok(GeneratedField::Workers),
11407 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11408 }
11409 }
11410 }
11411 deserializer.deserialize_identifier(GeneratedVisitor)
11412 }
11413 }
11414 struct GeneratedVisitor;
11415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11416 type Value = PinnedVersionsSummary;
11417
11418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11419 formatter.write_str("struct hummock.PinnedVersionsSummary")
11420 }
11421
11422 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
11423 where
11424 V: serde::de::MapAccess<'de>,
11425 {
11426 let mut pinned_versions__ = None;
11427 let mut workers__ = None;
11428 while let Some(k) = map_.next_key()? {
11429 match k {
11430 GeneratedField::PinnedVersions => {
11431 if pinned_versions__.is_some() {
11432 return Err(serde::de::Error::duplicate_field("pinnedVersions"));
11433 }
11434 pinned_versions__ = Some(map_.next_value()?);
11435 }
11436 GeneratedField::Workers => {
11437 if workers__.is_some() {
11438 return Err(serde::de::Error::duplicate_field("workers"));
11439 }
11440 workers__ = Some(
11441 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11442 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11443 );
11444 }
11445 }
11446 }
11447 Ok(PinnedVersionsSummary {
11448 pinned_versions: pinned_versions__.unwrap_or_default(),
11449 workers: workers__.unwrap_or_default(),
11450 })
11451 }
11452 }
11453 deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
11454 }
11455}
11456impl serde::Serialize for ReplayVersionDeltaRequest {
11457 #[allow(deprecated)]
11458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11459 where
11460 S: serde::Serializer,
11461 {
11462 use serde::ser::SerializeStruct;
11463 let mut len = 0;
11464 if self.version_delta.is_some() {
11465 len += 1;
11466 }
11467 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
11468 if let Some(v) = self.version_delta.as_ref() {
11469 struct_ser.serialize_field("versionDelta", v)?;
11470 }
11471 struct_ser.end()
11472 }
11473}
11474impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
11475 #[allow(deprecated)]
11476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11477 where
11478 D: serde::Deserializer<'de>,
11479 {
11480 const FIELDS: &[&str] = &[
11481 "version_delta",
11482 "versionDelta",
11483 ];
11484
11485 #[allow(clippy::enum_variant_names)]
11486 enum GeneratedField {
11487 VersionDelta,
11488 }
11489 impl<'de> serde::Deserialize<'de> for GeneratedField {
11490 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11491 where
11492 D: serde::Deserializer<'de>,
11493 {
11494 struct GeneratedVisitor;
11495
11496 impl serde::de::Visitor<'_> for GeneratedVisitor {
11497 type Value = GeneratedField;
11498
11499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11500 write!(formatter, "expected one of: {:?}", &FIELDS)
11501 }
11502
11503 #[allow(unused_variables)]
11504 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11505 where
11506 E: serde::de::Error,
11507 {
11508 match value {
11509 "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
11510 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11511 }
11512 }
11513 }
11514 deserializer.deserialize_identifier(GeneratedVisitor)
11515 }
11516 }
11517 struct GeneratedVisitor;
11518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11519 type Value = ReplayVersionDeltaRequest;
11520
11521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11522 formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
11523 }
11524
11525 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
11526 where
11527 V: serde::de::MapAccess<'de>,
11528 {
11529 let mut version_delta__ = None;
11530 while let Some(k) = map_.next_key()? {
11531 match k {
11532 GeneratedField::VersionDelta => {
11533 if version_delta__.is_some() {
11534 return Err(serde::de::Error::duplicate_field("versionDelta"));
11535 }
11536 version_delta__ = map_.next_value()?;
11537 }
11538 }
11539 }
11540 Ok(ReplayVersionDeltaRequest {
11541 version_delta: version_delta__,
11542 })
11543 }
11544 }
11545 deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
11546 }
11547}
11548impl serde::Serialize for ReplayVersionDeltaResponse {
11549 #[allow(deprecated)]
11550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11551 where
11552 S: serde::Serializer,
11553 {
11554 use serde::ser::SerializeStruct;
11555 let mut len = 0;
11556 if self.version.is_some() {
11557 len += 1;
11558 }
11559 if !self.modified_compaction_groups.is_empty() {
11560 len += 1;
11561 }
11562 let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
11563 if let Some(v) = self.version.as_ref() {
11564 struct_ser.serialize_field("version", v)?;
11565 }
11566 if !self.modified_compaction_groups.is_empty() {
11567 struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
11568 }
11569 struct_ser.end()
11570 }
11571}
11572impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
11573 #[allow(deprecated)]
11574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11575 where
11576 D: serde::Deserializer<'de>,
11577 {
11578 const FIELDS: &[&str] = &[
11579 "version",
11580 "modified_compaction_groups",
11581 "modifiedCompactionGroups",
11582 ];
11583
11584 #[allow(clippy::enum_variant_names)]
11585 enum GeneratedField {
11586 Version,
11587 ModifiedCompactionGroups,
11588 }
11589 impl<'de> serde::Deserialize<'de> for GeneratedField {
11590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11591 where
11592 D: serde::Deserializer<'de>,
11593 {
11594 struct GeneratedVisitor;
11595
11596 impl serde::de::Visitor<'_> for GeneratedVisitor {
11597 type Value = GeneratedField;
11598
11599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11600 write!(formatter, "expected one of: {:?}", &FIELDS)
11601 }
11602
11603 #[allow(unused_variables)]
11604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11605 where
11606 E: serde::de::Error,
11607 {
11608 match value {
11609 "version" => Ok(GeneratedField::Version),
11610 "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
11611 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11612 }
11613 }
11614 }
11615 deserializer.deserialize_identifier(GeneratedVisitor)
11616 }
11617 }
11618 struct GeneratedVisitor;
11619 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11620 type Value = ReplayVersionDeltaResponse;
11621
11622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11623 formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
11624 }
11625
11626 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
11627 where
11628 V: serde::de::MapAccess<'de>,
11629 {
11630 let mut version__ = None;
11631 let mut modified_compaction_groups__ = None;
11632 while let Some(k) = map_.next_key()? {
11633 match k {
11634 GeneratedField::Version => {
11635 if version__.is_some() {
11636 return Err(serde::de::Error::duplicate_field("version"));
11637 }
11638 version__ = map_.next_value()?;
11639 }
11640 GeneratedField::ModifiedCompactionGroups => {
11641 if modified_compaction_groups__.is_some() {
11642 return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
11643 }
11644 modified_compaction_groups__ =
11645 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11646 .into_iter().map(|x| x.0).collect())
11647 ;
11648 }
11649 }
11650 }
11651 Ok(ReplayVersionDeltaResponse {
11652 version: version__,
11653 modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
11654 })
11655 }
11656 }
11657 deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
11658 }
11659}
11660impl serde::Serialize for ReportCompactionTaskRequest {
11661 #[allow(deprecated)]
11662 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11663 where
11664 S: serde::Serializer,
11665 {
11666 use serde::ser::SerializeStruct;
11667 let mut len = 0;
11668 if self.event.is_some() {
11669 len += 1;
11670 }
11671 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
11672 if let Some(v) = self.event.as_ref() {
11673 match v {
11674 report_compaction_task_request::Event::ReportTask(v) => {
11675 struct_ser.serialize_field("reportTask", v)?;
11676 }
11677 report_compaction_task_request::Event::HeartBeat(v) => {
11678 struct_ser.serialize_field("heartBeat", v)?;
11679 }
11680 }
11681 }
11682 struct_ser.end()
11683 }
11684}
11685impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
11686 #[allow(deprecated)]
11687 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11688 where
11689 D: serde::Deserializer<'de>,
11690 {
11691 const FIELDS: &[&str] = &[
11692 "report_task",
11693 "reportTask",
11694 "heart_beat",
11695 "heartBeat",
11696 ];
11697
11698 #[allow(clippy::enum_variant_names)]
11699 enum GeneratedField {
11700 ReportTask,
11701 HeartBeat,
11702 }
11703 impl<'de> serde::Deserialize<'de> for GeneratedField {
11704 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11705 where
11706 D: serde::Deserializer<'de>,
11707 {
11708 struct GeneratedVisitor;
11709
11710 impl serde::de::Visitor<'_> for GeneratedVisitor {
11711 type Value = GeneratedField;
11712
11713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11714 write!(formatter, "expected one of: {:?}", &FIELDS)
11715 }
11716
11717 #[allow(unused_variables)]
11718 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11719 where
11720 E: serde::de::Error,
11721 {
11722 match value {
11723 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
11724 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
11725 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11726 }
11727 }
11728 }
11729 deserializer.deserialize_identifier(GeneratedVisitor)
11730 }
11731 }
11732 struct GeneratedVisitor;
11733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11734 type Value = ReportCompactionTaskRequest;
11735
11736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11737 formatter.write_str("struct hummock.ReportCompactionTaskRequest")
11738 }
11739
11740 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
11741 where
11742 V: serde::de::MapAccess<'de>,
11743 {
11744 let mut event__ = None;
11745 while let Some(k) = map_.next_key()? {
11746 match k {
11747 GeneratedField::ReportTask => {
11748 if event__.is_some() {
11749 return Err(serde::de::Error::duplicate_field("reportTask"));
11750 }
11751 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
11752;
11753 }
11754 GeneratedField::HeartBeat => {
11755 if event__.is_some() {
11756 return Err(serde::de::Error::duplicate_field("heartBeat"));
11757 }
11758 event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
11759;
11760 }
11761 }
11762 }
11763 Ok(ReportCompactionTaskRequest {
11764 event: event__,
11765 })
11766 }
11767 }
11768 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
11769 }
11770}
11771impl serde::Serialize for report_compaction_task_request::HeartBeat {
11772 #[allow(deprecated)]
11773 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11774 where
11775 S: serde::Serializer,
11776 {
11777 use serde::ser::SerializeStruct;
11778 let mut len = 0;
11779 if !self.progress.is_empty() {
11780 len += 1;
11781 }
11782 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
11783 if !self.progress.is_empty() {
11784 struct_ser.serialize_field("progress", &self.progress)?;
11785 }
11786 struct_ser.end()
11787 }
11788}
11789impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
11790 #[allow(deprecated)]
11791 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11792 where
11793 D: serde::Deserializer<'de>,
11794 {
11795 const FIELDS: &[&str] = &[
11796 "progress",
11797 ];
11798
11799 #[allow(clippy::enum_variant_names)]
11800 enum GeneratedField {
11801 Progress,
11802 }
11803 impl<'de> serde::Deserialize<'de> for GeneratedField {
11804 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11805 where
11806 D: serde::Deserializer<'de>,
11807 {
11808 struct GeneratedVisitor;
11809
11810 impl serde::de::Visitor<'_> for GeneratedVisitor {
11811 type Value = GeneratedField;
11812
11813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11814 write!(formatter, "expected one of: {:?}", &FIELDS)
11815 }
11816
11817 #[allow(unused_variables)]
11818 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11819 where
11820 E: serde::de::Error,
11821 {
11822 match value {
11823 "progress" => Ok(GeneratedField::Progress),
11824 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11825 }
11826 }
11827 }
11828 deserializer.deserialize_identifier(GeneratedVisitor)
11829 }
11830 }
11831 struct GeneratedVisitor;
11832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11833 type Value = report_compaction_task_request::HeartBeat;
11834
11835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11836 formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
11837 }
11838
11839 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
11840 where
11841 V: serde::de::MapAccess<'de>,
11842 {
11843 let mut progress__ = None;
11844 while let Some(k) = map_.next_key()? {
11845 match k {
11846 GeneratedField::Progress => {
11847 if progress__.is_some() {
11848 return Err(serde::de::Error::duplicate_field("progress"));
11849 }
11850 progress__ = Some(map_.next_value()?);
11851 }
11852 }
11853 }
11854 Ok(report_compaction_task_request::HeartBeat {
11855 progress: progress__.unwrap_or_default(),
11856 })
11857 }
11858 }
11859 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
11860 }
11861}
11862impl serde::Serialize for report_compaction_task_request::ReportTask {
11863 #[allow(deprecated)]
11864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11865 where
11866 S: serde::Serializer,
11867 {
11868 use serde::ser::SerializeStruct;
11869 let mut len = 0;
11870 if self.compact_task.is_some() {
11871 len += 1;
11872 }
11873 if !self.table_stats_change.is_empty() {
11874 len += 1;
11875 }
11876 if !self.object_timestamps.is_empty() {
11877 len += 1;
11878 }
11879 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
11880 if let Some(v) = self.compact_task.as_ref() {
11881 struct_ser.serialize_field("compactTask", v)?;
11882 }
11883 if !self.table_stats_change.is_empty() {
11884 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
11885 }
11886 if !self.object_timestamps.is_empty() {
11887 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
11888 .map(|(k, v)| (k, v.to_string())).collect();
11889 struct_ser.serialize_field("objectTimestamps", &v)?;
11890 }
11891 struct_ser.end()
11892 }
11893}
11894impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
11895 #[allow(deprecated)]
11896 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11897 where
11898 D: serde::Deserializer<'de>,
11899 {
11900 const FIELDS: &[&str] = &[
11901 "compact_task",
11902 "compactTask",
11903 "table_stats_change",
11904 "tableStatsChange",
11905 "object_timestamps",
11906 "objectTimestamps",
11907 ];
11908
11909 #[allow(clippy::enum_variant_names)]
11910 enum GeneratedField {
11911 CompactTask,
11912 TableStatsChange,
11913 ObjectTimestamps,
11914 }
11915 impl<'de> serde::Deserialize<'de> for GeneratedField {
11916 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11917 where
11918 D: serde::Deserializer<'de>,
11919 {
11920 struct GeneratedVisitor;
11921
11922 impl serde::de::Visitor<'_> for GeneratedVisitor {
11923 type Value = GeneratedField;
11924
11925 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11926 write!(formatter, "expected one of: {:?}", &FIELDS)
11927 }
11928
11929 #[allow(unused_variables)]
11930 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11931 where
11932 E: serde::de::Error,
11933 {
11934 match value {
11935 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
11936 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
11937 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
11938 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11939 }
11940 }
11941 }
11942 deserializer.deserialize_identifier(GeneratedVisitor)
11943 }
11944 }
11945 struct GeneratedVisitor;
11946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11947 type Value = report_compaction_task_request::ReportTask;
11948
11949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11950 formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
11951 }
11952
11953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
11954 where
11955 V: serde::de::MapAccess<'de>,
11956 {
11957 let mut compact_task__ = None;
11958 let mut table_stats_change__ = None;
11959 let mut object_timestamps__ = None;
11960 while let Some(k) = map_.next_key()? {
11961 match k {
11962 GeneratedField::CompactTask => {
11963 if compact_task__.is_some() {
11964 return Err(serde::de::Error::duplicate_field("compactTask"));
11965 }
11966 compact_task__ = map_.next_value()?;
11967 }
11968 GeneratedField::TableStatsChange => {
11969 if table_stats_change__.is_some() {
11970 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
11971 }
11972 table_stats_change__ = Some(
11973 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11974 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11975 );
11976 }
11977 GeneratedField::ObjectTimestamps => {
11978 if object_timestamps__.is_some() {
11979 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
11980 }
11981 object_timestamps__ = Some(
11982 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
11983 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
11984 );
11985 }
11986 }
11987 }
11988 Ok(report_compaction_task_request::ReportTask {
11989 compact_task: compact_task__,
11990 table_stats_change: table_stats_change__.unwrap_or_default(),
11991 object_timestamps: object_timestamps__.unwrap_or_default(),
11992 })
11993 }
11994 }
11995 deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
11996 }
11997}
11998impl serde::Serialize for ReportCompactionTaskResponse {
11999 #[allow(deprecated)]
12000 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12001 where
12002 S: serde::Serializer,
12003 {
12004 use serde::ser::SerializeStruct;
12005 let mut len = 0;
12006 if self.status.is_some() {
12007 len += 1;
12008 }
12009 let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
12010 if let Some(v) = self.status.as_ref() {
12011 struct_ser.serialize_field("status", v)?;
12012 }
12013 struct_ser.end()
12014 }
12015}
12016impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
12017 #[allow(deprecated)]
12018 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12019 where
12020 D: serde::Deserializer<'de>,
12021 {
12022 const FIELDS: &[&str] = &[
12023 "status",
12024 ];
12025
12026 #[allow(clippy::enum_variant_names)]
12027 enum GeneratedField {
12028 Status,
12029 }
12030 impl<'de> serde::Deserialize<'de> for GeneratedField {
12031 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12032 where
12033 D: serde::Deserializer<'de>,
12034 {
12035 struct GeneratedVisitor;
12036
12037 impl serde::de::Visitor<'_> for GeneratedVisitor {
12038 type Value = GeneratedField;
12039
12040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12041 write!(formatter, "expected one of: {:?}", &FIELDS)
12042 }
12043
12044 #[allow(unused_variables)]
12045 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12046 where
12047 E: serde::de::Error,
12048 {
12049 match value {
12050 "status" => Ok(GeneratedField::Status),
12051 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12052 }
12053 }
12054 }
12055 deserializer.deserialize_identifier(GeneratedVisitor)
12056 }
12057 }
12058 struct GeneratedVisitor;
12059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12060 type Value = ReportCompactionTaskResponse;
12061
12062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12063 formatter.write_str("struct hummock.ReportCompactionTaskResponse")
12064 }
12065
12066 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
12067 where
12068 V: serde::de::MapAccess<'de>,
12069 {
12070 let mut status__ = None;
12071 while let Some(k) = map_.next_key()? {
12072 match k {
12073 GeneratedField::Status => {
12074 if status__.is_some() {
12075 return Err(serde::de::Error::duplicate_field("status"));
12076 }
12077 status__ = map_.next_value()?;
12078 }
12079 }
12080 }
12081 Ok(ReportCompactionTaskResponse {
12082 status: status__,
12083 })
12084 }
12085 }
12086 deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
12087 }
12088}
12089impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
12090 #[allow(deprecated)]
12091 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12092 where
12093 S: serde::Serializer,
12094 {
12095 use serde::ser::SerializeStruct;
12096 let len = 0;
12097 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
12098 struct_ser.end()
12099 }
12100}
12101impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
12102 #[allow(deprecated)]
12103 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12104 where
12105 D: serde::Deserializer<'de>,
12106 {
12107 const FIELDS: &[&str] = &[
12108 ];
12109
12110 #[allow(clippy::enum_variant_names)]
12111 enum GeneratedField {
12112 }
12113 impl<'de> serde::Deserialize<'de> for GeneratedField {
12114 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12115 where
12116 D: serde::Deserializer<'de>,
12117 {
12118 struct GeneratedVisitor;
12119
12120 impl serde::de::Visitor<'_> for GeneratedVisitor {
12121 type Value = GeneratedField;
12122
12123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12124 write!(formatter, "expected one of: {:?}", &FIELDS)
12125 }
12126
12127 #[allow(unused_variables)]
12128 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12129 where
12130 E: serde::de::Error,
12131 {
12132 Err(serde::de::Error::unknown_field(value, FIELDS))
12133 }
12134 }
12135 deserializer.deserialize_identifier(GeneratedVisitor)
12136 }
12137 }
12138 struct GeneratedVisitor;
12139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12140 type Value = RiseCtlGetCheckpointVersionRequest;
12141
12142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12143 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
12144 }
12145
12146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
12147 where
12148 V: serde::de::MapAccess<'de>,
12149 {
12150 while map_.next_key::<GeneratedField>()?.is_some() {
12151 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12152 }
12153 Ok(RiseCtlGetCheckpointVersionRequest {
12154 })
12155 }
12156 }
12157 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
12158 }
12159}
12160impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
12161 #[allow(deprecated)]
12162 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12163 where
12164 S: serde::Serializer,
12165 {
12166 use serde::ser::SerializeStruct;
12167 let mut len = 0;
12168 if self.checkpoint_version.is_some() {
12169 len += 1;
12170 }
12171 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
12172 if let Some(v) = self.checkpoint_version.as_ref() {
12173 struct_ser.serialize_field("checkpointVersion", v)?;
12174 }
12175 struct_ser.end()
12176 }
12177}
12178impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
12179 #[allow(deprecated)]
12180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12181 where
12182 D: serde::Deserializer<'de>,
12183 {
12184 const FIELDS: &[&str] = &[
12185 "checkpoint_version",
12186 "checkpointVersion",
12187 ];
12188
12189 #[allow(clippy::enum_variant_names)]
12190 enum GeneratedField {
12191 CheckpointVersion,
12192 }
12193 impl<'de> serde::Deserialize<'de> for GeneratedField {
12194 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12195 where
12196 D: serde::Deserializer<'de>,
12197 {
12198 struct GeneratedVisitor;
12199
12200 impl serde::de::Visitor<'_> for GeneratedVisitor {
12201 type Value = GeneratedField;
12202
12203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12204 write!(formatter, "expected one of: {:?}", &FIELDS)
12205 }
12206
12207 #[allow(unused_variables)]
12208 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12209 where
12210 E: serde::de::Error,
12211 {
12212 match value {
12213 "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
12214 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12215 }
12216 }
12217 }
12218 deserializer.deserialize_identifier(GeneratedVisitor)
12219 }
12220 }
12221 struct GeneratedVisitor;
12222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12223 type Value = RiseCtlGetCheckpointVersionResponse;
12224
12225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12226 formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
12227 }
12228
12229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
12230 where
12231 V: serde::de::MapAccess<'de>,
12232 {
12233 let mut checkpoint_version__ = None;
12234 while let Some(k) = map_.next_key()? {
12235 match k {
12236 GeneratedField::CheckpointVersion => {
12237 if checkpoint_version__.is_some() {
12238 return Err(serde::de::Error::duplicate_field("checkpointVersion"));
12239 }
12240 checkpoint_version__ = map_.next_value()?;
12241 }
12242 }
12243 }
12244 Ok(RiseCtlGetCheckpointVersionResponse {
12245 checkpoint_version: checkpoint_version__,
12246 })
12247 }
12248 }
12249 deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
12250 }
12251}
12252impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
12253 #[allow(deprecated)]
12254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12255 where
12256 S: serde::Serializer,
12257 {
12258 use serde::ser::SerializeStruct;
12259 let len = 0;
12260 let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
12261 struct_ser.end()
12262 }
12263}
12264impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
12265 #[allow(deprecated)]
12266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12267 where
12268 D: serde::Deserializer<'de>,
12269 {
12270 const FIELDS: &[&str] = &[
12271 ];
12272
12273 #[allow(clippy::enum_variant_names)]
12274 enum GeneratedField {
12275 }
12276 impl<'de> serde::Deserialize<'de> for GeneratedField {
12277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12278 where
12279 D: serde::Deserializer<'de>,
12280 {
12281 struct GeneratedVisitor;
12282
12283 impl serde::de::Visitor<'_> for GeneratedVisitor {
12284 type Value = GeneratedField;
12285
12286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12287 write!(formatter, "expected one of: {:?}", &FIELDS)
12288 }
12289
12290 #[allow(unused_variables)]
12291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12292 where
12293 E: serde::de::Error,
12294 {
12295 Err(serde::de::Error::unknown_field(value, FIELDS))
12296 }
12297 }
12298 deserializer.deserialize_identifier(GeneratedVisitor)
12299 }
12300 }
12301 struct GeneratedVisitor;
12302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12303 type Value = RiseCtlGetPinnedVersionsSummaryRequest;
12304
12305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12306 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
12307 }
12308
12309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
12310 where
12311 V: serde::de::MapAccess<'de>,
12312 {
12313 while map_.next_key::<GeneratedField>()?.is_some() {
12314 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12315 }
12316 Ok(RiseCtlGetPinnedVersionsSummaryRequest {
12317 })
12318 }
12319 }
12320 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
12321 }
12322}
12323impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
12324 #[allow(deprecated)]
12325 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12326 where
12327 S: serde::Serializer,
12328 {
12329 use serde::ser::SerializeStruct;
12330 let mut len = 0;
12331 if self.summary.is_some() {
12332 len += 1;
12333 }
12334 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
12335 if let Some(v) = self.summary.as_ref() {
12336 struct_ser.serialize_field("summary", v)?;
12337 }
12338 struct_ser.end()
12339 }
12340}
12341impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
12342 #[allow(deprecated)]
12343 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12344 where
12345 D: serde::Deserializer<'de>,
12346 {
12347 const FIELDS: &[&str] = &[
12348 "summary",
12349 ];
12350
12351 #[allow(clippy::enum_variant_names)]
12352 enum GeneratedField {
12353 Summary,
12354 }
12355 impl<'de> serde::Deserialize<'de> for GeneratedField {
12356 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12357 where
12358 D: serde::Deserializer<'de>,
12359 {
12360 struct GeneratedVisitor;
12361
12362 impl serde::de::Visitor<'_> for GeneratedVisitor {
12363 type Value = GeneratedField;
12364
12365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12366 write!(formatter, "expected one of: {:?}", &FIELDS)
12367 }
12368
12369 #[allow(unused_variables)]
12370 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12371 where
12372 E: serde::de::Error,
12373 {
12374 match value {
12375 "summary" => Ok(GeneratedField::Summary),
12376 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12377 }
12378 }
12379 }
12380 deserializer.deserialize_identifier(GeneratedVisitor)
12381 }
12382 }
12383 struct GeneratedVisitor;
12384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12385 type Value = RiseCtlGetPinnedVersionsSummaryResponse;
12386
12387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12388 formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
12389 }
12390
12391 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
12392 where
12393 V: serde::de::MapAccess<'de>,
12394 {
12395 let mut summary__ = None;
12396 while let Some(k) = map_.next_key()? {
12397 match k {
12398 GeneratedField::Summary => {
12399 if summary__.is_some() {
12400 return Err(serde::de::Error::duplicate_field("summary"));
12401 }
12402 summary__ = map_.next_value()?;
12403 }
12404 }
12405 }
12406 Ok(RiseCtlGetPinnedVersionsSummaryResponse {
12407 summary: summary__,
12408 })
12409 }
12410 }
12411 deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
12412 }
12413}
12414impl serde::Serialize for RiseCtlListCompactionGroupRequest {
12415 #[allow(deprecated)]
12416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12417 where
12418 S: serde::Serializer,
12419 {
12420 use serde::ser::SerializeStruct;
12421 let len = 0;
12422 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
12423 struct_ser.end()
12424 }
12425}
12426impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
12427 #[allow(deprecated)]
12428 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12429 where
12430 D: serde::Deserializer<'de>,
12431 {
12432 const FIELDS: &[&str] = &[
12433 ];
12434
12435 #[allow(clippy::enum_variant_names)]
12436 enum GeneratedField {
12437 }
12438 impl<'de> serde::Deserialize<'de> for GeneratedField {
12439 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12440 where
12441 D: serde::Deserializer<'de>,
12442 {
12443 struct GeneratedVisitor;
12444
12445 impl serde::de::Visitor<'_> for GeneratedVisitor {
12446 type Value = GeneratedField;
12447
12448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12449 write!(formatter, "expected one of: {:?}", &FIELDS)
12450 }
12451
12452 #[allow(unused_variables)]
12453 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12454 where
12455 E: serde::de::Error,
12456 {
12457 Err(serde::de::Error::unknown_field(value, FIELDS))
12458 }
12459 }
12460 deserializer.deserialize_identifier(GeneratedVisitor)
12461 }
12462 }
12463 struct GeneratedVisitor;
12464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12465 type Value = RiseCtlListCompactionGroupRequest;
12466
12467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12468 formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
12469 }
12470
12471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
12472 where
12473 V: serde::de::MapAccess<'de>,
12474 {
12475 while map_.next_key::<GeneratedField>()?.is_some() {
12476 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12477 }
12478 Ok(RiseCtlListCompactionGroupRequest {
12479 })
12480 }
12481 }
12482 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
12483 }
12484}
12485impl serde::Serialize for RiseCtlListCompactionGroupResponse {
12486 #[allow(deprecated)]
12487 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12488 where
12489 S: serde::Serializer,
12490 {
12491 use serde::ser::SerializeStruct;
12492 let mut len = 0;
12493 if self.status.is_some() {
12494 len += 1;
12495 }
12496 if !self.compaction_groups.is_empty() {
12497 len += 1;
12498 }
12499 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
12500 if let Some(v) = self.status.as_ref() {
12501 struct_ser.serialize_field("status", v)?;
12502 }
12503 if !self.compaction_groups.is_empty() {
12504 struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
12505 }
12506 struct_ser.end()
12507 }
12508}
12509impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
12510 #[allow(deprecated)]
12511 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12512 where
12513 D: serde::Deserializer<'de>,
12514 {
12515 const FIELDS: &[&str] = &[
12516 "status",
12517 "compaction_groups",
12518 "compactionGroups",
12519 ];
12520
12521 #[allow(clippy::enum_variant_names)]
12522 enum GeneratedField {
12523 Status,
12524 CompactionGroups,
12525 }
12526 impl<'de> serde::Deserialize<'de> for GeneratedField {
12527 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12528 where
12529 D: serde::Deserializer<'de>,
12530 {
12531 struct GeneratedVisitor;
12532
12533 impl serde::de::Visitor<'_> for GeneratedVisitor {
12534 type Value = GeneratedField;
12535
12536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12537 write!(formatter, "expected one of: {:?}", &FIELDS)
12538 }
12539
12540 #[allow(unused_variables)]
12541 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12542 where
12543 E: serde::de::Error,
12544 {
12545 match value {
12546 "status" => Ok(GeneratedField::Status),
12547 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
12548 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12549 }
12550 }
12551 }
12552 deserializer.deserialize_identifier(GeneratedVisitor)
12553 }
12554 }
12555 struct GeneratedVisitor;
12556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12557 type Value = RiseCtlListCompactionGroupResponse;
12558
12559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12560 formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
12561 }
12562
12563 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
12564 where
12565 V: serde::de::MapAccess<'de>,
12566 {
12567 let mut status__ = None;
12568 let mut compaction_groups__ = None;
12569 while let Some(k) = map_.next_key()? {
12570 match k {
12571 GeneratedField::Status => {
12572 if status__.is_some() {
12573 return Err(serde::de::Error::duplicate_field("status"));
12574 }
12575 status__ = map_.next_value()?;
12576 }
12577 GeneratedField::CompactionGroups => {
12578 if compaction_groups__.is_some() {
12579 return Err(serde::de::Error::duplicate_field("compactionGroups"));
12580 }
12581 compaction_groups__ = Some(map_.next_value()?);
12582 }
12583 }
12584 }
12585 Ok(RiseCtlListCompactionGroupResponse {
12586 status: status__,
12587 compaction_groups: compaction_groups__.unwrap_or_default(),
12588 })
12589 }
12590 }
12591 deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
12592 }
12593}
12594impl serde::Serialize for RiseCtlListCompactionStatusRequest {
12595 #[allow(deprecated)]
12596 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12597 where
12598 S: serde::Serializer,
12599 {
12600 use serde::ser::SerializeStruct;
12601 let len = 0;
12602 let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
12603 struct_ser.end()
12604 }
12605}
12606impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
12607 #[allow(deprecated)]
12608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12609 where
12610 D: serde::Deserializer<'de>,
12611 {
12612 const FIELDS: &[&str] = &[
12613 ];
12614
12615 #[allow(clippy::enum_variant_names)]
12616 enum GeneratedField {
12617 }
12618 impl<'de> serde::Deserialize<'de> for GeneratedField {
12619 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12620 where
12621 D: serde::Deserializer<'de>,
12622 {
12623 struct GeneratedVisitor;
12624
12625 impl serde::de::Visitor<'_> for GeneratedVisitor {
12626 type Value = GeneratedField;
12627
12628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12629 write!(formatter, "expected one of: {:?}", &FIELDS)
12630 }
12631
12632 #[allow(unused_variables)]
12633 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12634 where
12635 E: serde::de::Error,
12636 {
12637 Err(serde::de::Error::unknown_field(value, FIELDS))
12638 }
12639 }
12640 deserializer.deserialize_identifier(GeneratedVisitor)
12641 }
12642 }
12643 struct GeneratedVisitor;
12644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12645 type Value = RiseCtlListCompactionStatusRequest;
12646
12647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12648 formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
12649 }
12650
12651 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
12652 where
12653 V: serde::de::MapAccess<'de>,
12654 {
12655 while map_.next_key::<GeneratedField>()?.is_some() {
12656 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12657 }
12658 Ok(RiseCtlListCompactionStatusRequest {
12659 })
12660 }
12661 }
12662 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
12663 }
12664}
12665impl serde::Serialize for RiseCtlListCompactionStatusResponse {
12666 #[allow(deprecated)]
12667 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12668 where
12669 S: serde::Serializer,
12670 {
12671 use serde::ser::SerializeStruct;
12672 let mut len = 0;
12673 if !self.compaction_statuses.is_empty() {
12674 len += 1;
12675 }
12676 if !self.task_assignment.is_empty() {
12677 len += 1;
12678 }
12679 if !self.task_progress.is_empty() {
12680 len += 1;
12681 }
12682 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
12683 if !self.compaction_statuses.is_empty() {
12684 struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
12685 }
12686 if !self.task_assignment.is_empty() {
12687 struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
12688 }
12689 if !self.task_progress.is_empty() {
12690 struct_ser.serialize_field("taskProgress", &self.task_progress)?;
12691 }
12692 struct_ser.end()
12693 }
12694}
12695impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
12696 #[allow(deprecated)]
12697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12698 where
12699 D: serde::Deserializer<'de>,
12700 {
12701 const FIELDS: &[&str] = &[
12702 "compaction_statuses",
12703 "compactionStatuses",
12704 "task_assignment",
12705 "taskAssignment",
12706 "task_progress",
12707 "taskProgress",
12708 ];
12709
12710 #[allow(clippy::enum_variant_names)]
12711 enum GeneratedField {
12712 CompactionStatuses,
12713 TaskAssignment,
12714 TaskProgress,
12715 }
12716 impl<'de> serde::Deserialize<'de> for GeneratedField {
12717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12718 where
12719 D: serde::Deserializer<'de>,
12720 {
12721 struct GeneratedVisitor;
12722
12723 impl serde::de::Visitor<'_> for GeneratedVisitor {
12724 type Value = GeneratedField;
12725
12726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12727 write!(formatter, "expected one of: {:?}", &FIELDS)
12728 }
12729
12730 #[allow(unused_variables)]
12731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12732 where
12733 E: serde::de::Error,
12734 {
12735 match value {
12736 "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
12737 "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
12738 "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
12739 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12740 }
12741 }
12742 }
12743 deserializer.deserialize_identifier(GeneratedVisitor)
12744 }
12745 }
12746 struct GeneratedVisitor;
12747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12748 type Value = RiseCtlListCompactionStatusResponse;
12749
12750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12751 formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
12752 }
12753
12754 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
12755 where
12756 V: serde::de::MapAccess<'de>,
12757 {
12758 let mut compaction_statuses__ = None;
12759 let mut task_assignment__ = None;
12760 let mut task_progress__ = None;
12761 while let Some(k) = map_.next_key()? {
12762 match k {
12763 GeneratedField::CompactionStatuses => {
12764 if compaction_statuses__.is_some() {
12765 return Err(serde::de::Error::duplicate_field("compactionStatuses"));
12766 }
12767 compaction_statuses__ = Some(map_.next_value()?);
12768 }
12769 GeneratedField::TaskAssignment => {
12770 if task_assignment__.is_some() {
12771 return Err(serde::de::Error::duplicate_field("taskAssignment"));
12772 }
12773 task_assignment__ = Some(map_.next_value()?);
12774 }
12775 GeneratedField::TaskProgress => {
12776 if task_progress__.is_some() {
12777 return Err(serde::de::Error::duplicate_field("taskProgress"));
12778 }
12779 task_progress__ = Some(map_.next_value()?);
12780 }
12781 }
12782 }
12783 Ok(RiseCtlListCompactionStatusResponse {
12784 compaction_statuses: compaction_statuses__.unwrap_or_default(),
12785 task_assignment: task_assignment__.unwrap_or_default(),
12786 task_progress: task_progress__.unwrap_or_default(),
12787 })
12788 }
12789 }
12790 deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
12791 }
12792}
12793impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
12794 #[allow(deprecated)]
12795 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12796 where
12797 S: serde::Serializer,
12798 {
12799 use serde::ser::SerializeStruct;
12800 let len = 0;
12801 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
12802 struct_ser.end()
12803 }
12804}
12805impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
12806 #[allow(deprecated)]
12807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12808 where
12809 D: serde::Deserializer<'de>,
12810 {
12811 const FIELDS: &[&str] = &[
12812 ];
12813
12814 #[allow(clippy::enum_variant_names)]
12815 enum GeneratedField {
12816 }
12817 impl<'de> serde::Deserialize<'de> for GeneratedField {
12818 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12819 where
12820 D: serde::Deserializer<'de>,
12821 {
12822 struct GeneratedVisitor;
12823
12824 impl serde::de::Visitor<'_> for GeneratedVisitor {
12825 type Value = GeneratedField;
12826
12827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12828 write!(formatter, "expected one of: {:?}", &FIELDS)
12829 }
12830
12831 #[allow(unused_variables)]
12832 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12833 where
12834 E: serde::de::Error,
12835 {
12836 Err(serde::de::Error::unknown_field(value, FIELDS))
12837 }
12838 }
12839 deserializer.deserialize_identifier(GeneratedVisitor)
12840 }
12841 }
12842 struct GeneratedVisitor;
12843 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12844 type Value = RiseCtlPauseVersionCheckpointRequest;
12845
12846 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12847 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
12848 }
12849
12850 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
12851 where
12852 V: serde::de::MapAccess<'de>,
12853 {
12854 while map_.next_key::<GeneratedField>()?.is_some() {
12855 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12856 }
12857 Ok(RiseCtlPauseVersionCheckpointRequest {
12858 })
12859 }
12860 }
12861 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12862 }
12863}
12864impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
12865 #[allow(deprecated)]
12866 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12867 where
12868 S: serde::Serializer,
12869 {
12870 use serde::ser::SerializeStruct;
12871 let len = 0;
12872 let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
12873 struct_ser.end()
12874 }
12875}
12876impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
12877 #[allow(deprecated)]
12878 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12879 where
12880 D: serde::Deserializer<'de>,
12881 {
12882 const FIELDS: &[&str] = &[
12883 ];
12884
12885 #[allow(clippy::enum_variant_names)]
12886 enum GeneratedField {
12887 }
12888 impl<'de> serde::Deserialize<'de> for GeneratedField {
12889 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12890 where
12891 D: serde::Deserializer<'de>,
12892 {
12893 struct GeneratedVisitor;
12894
12895 impl serde::de::Visitor<'_> for GeneratedVisitor {
12896 type Value = GeneratedField;
12897
12898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12899 write!(formatter, "expected one of: {:?}", &FIELDS)
12900 }
12901
12902 #[allow(unused_variables)]
12903 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12904 where
12905 E: serde::de::Error,
12906 {
12907 Err(serde::de::Error::unknown_field(value, FIELDS))
12908 }
12909 }
12910 deserializer.deserialize_identifier(GeneratedVisitor)
12911 }
12912 }
12913 struct GeneratedVisitor;
12914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12915 type Value = RiseCtlPauseVersionCheckpointResponse;
12916
12917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12918 formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
12919 }
12920
12921 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
12922 where
12923 V: serde::de::MapAccess<'de>,
12924 {
12925 while map_.next_key::<GeneratedField>()?.is_some() {
12926 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12927 }
12928 Ok(RiseCtlPauseVersionCheckpointResponse {
12929 })
12930 }
12931 }
12932 deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
12933 }
12934}
12935impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
12936 #[allow(deprecated)]
12937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12938 where
12939 S: serde::Serializer,
12940 {
12941 use serde::ser::SerializeStruct;
12942 let len = 0;
12943 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
12944 struct_ser.end()
12945 }
12946}
12947impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
12948 #[allow(deprecated)]
12949 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12950 where
12951 D: serde::Deserializer<'de>,
12952 {
12953 const FIELDS: &[&str] = &[
12954 ];
12955
12956 #[allow(clippy::enum_variant_names)]
12957 enum GeneratedField {
12958 }
12959 impl<'de> serde::Deserialize<'de> for GeneratedField {
12960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12961 where
12962 D: serde::Deserializer<'de>,
12963 {
12964 struct GeneratedVisitor;
12965
12966 impl serde::de::Visitor<'_> for GeneratedVisitor {
12967 type Value = GeneratedField;
12968
12969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12970 write!(formatter, "expected one of: {:?}", &FIELDS)
12971 }
12972
12973 #[allow(unused_variables)]
12974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12975 where
12976 E: serde::de::Error,
12977 {
12978 Err(serde::de::Error::unknown_field(value, FIELDS))
12979 }
12980 }
12981 deserializer.deserialize_identifier(GeneratedVisitor)
12982 }
12983 }
12984 struct GeneratedVisitor;
12985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12986 type Value = RiseCtlRebuildTableStatsRequest;
12987
12988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12989 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
12990 }
12991
12992 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
12993 where
12994 V: serde::de::MapAccess<'de>,
12995 {
12996 while map_.next_key::<GeneratedField>()?.is_some() {
12997 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12998 }
12999 Ok(RiseCtlRebuildTableStatsRequest {
13000 })
13001 }
13002 }
13003 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
13004 }
13005}
13006impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
13007 #[allow(deprecated)]
13008 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13009 where
13010 S: serde::Serializer,
13011 {
13012 use serde::ser::SerializeStruct;
13013 let len = 0;
13014 let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
13015 struct_ser.end()
13016 }
13017}
13018impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
13019 #[allow(deprecated)]
13020 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13021 where
13022 D: serde::Deserializer<'de>,
13023 {
13024 const FIELDS: &[&str] = &[
13025 ];
13026
13027 #[allow(clippy::enum_variant_names)]
13028 enum GeneratedField {
13029 }
13030 impl<'de> serde::Deserialize<'de> for GeneratedField {
13031 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13032 where
13033 D: serde::Deserializer<'de>,
13034 {
13035 struct GeneratedVisitor;
13036
13037 impl serde::de::Visitor<'_> for GeneratedVisitor {
13038 type Value = GeneratedField;
13039
13040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13041 write!(formatter, "expected one of: {:?}", &FIELDS)
13042 }
13043
13044 #[allow(unused_variables)]
13045 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13046 where
13047 E: serde::de::Error,
13048 {
13049 Err(serde::de::Error::unknown_field(value, FIELDS))
13050 }
13051 }
13052 deserializer.deserialize_identifier(GeneratedVisitor)
13053 }
13054 }
13055 struct GeneratedVisitor;
13056 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13057 type Value = RiseCtlRebuildTableStatsResponse;
13058
13059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13060 formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
13061 }
13062
13063 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
13064 where
13065 V: serde::de::MapAccess<'de>,
13066 {
13067 while map_.next_key::<GeneratedField>()?.is_some() {
13068 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13069 }
13070 Ok(RiseCtlRebuildTableStatsResponse {
13071 })
13072 }
13073 }
13074 deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
13075 }
13076}
13077impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
13078 #[allow(deprecated)]
13079 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13080 where
13081 S: serde::Serializer,
13082 {
13083 use serde::ser::SerializeStruct;
13084 let len = 0;
13085 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
13086 struct_ser.end()
13087 }
13088}
13089impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
13090 #[allow(deprecated)]
13091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13092 where
13093 D: serde::Deserializer<'de>,
13094 {
13095 const FIELDS: &[&str] = &[
13096 ];
13097
13098 #[allow(clippy::enum_variant_names)]
13099 enum GeneratedField {
13100 }
13101 impl<'de> serde::Deserialize<'de> for GeneratedField {
13102 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13103 where
13104 D: serde::Deserializer<'de>,
13105 {
13106 struct GeneratedVisitor;
13107
13108 impl serde::de::Visitor<'_> for GeneratedVisitor {
13109 type Value = GeneratedField;
13110
13111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13112 write!(formatter, "expected one of: {:?}", &FIELDS)
13113 }
13114
13115 #[allow(unused_variables)]
13116 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13117 where
13118 E: serde::de::Error,
13119 {
13120 Err(serde::de::Error::unknown_field(value, FIELDS))
13121 }
13122 }
13123 deserializer.deserialize_identifier(GeneratedVisitor)
13124 }
13125 }
13126 struct GeneratedVisitor;
13127 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13128 type Value = RiseCtlResumeVersionCheckpointRequest;
13129
13130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13131 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
13132 }
13133
13134 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
13135 where
13136 V: serde::de::MapAccess<'de>,
13137 {
13138 while map_.next_key::<GeneratedField>()?.is_some() {
13139 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13140 }
13141 Ok(RiseCtlResumeVersionCheckpointRequest {
13142 })
13143 }
13144 }
13145 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
13146 }
13147}
13148impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
13149 #[allow(deprecated)]
13150 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13151 where
13152 S: serde::Serializer,
13153 {
13154 use serde::ser::SerializeStruct;
13155 let len = 0;
13156 let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
13157 struct_ser.end()
13158 }
13159}
13160impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
13161 #[allow(deprecated)]
13162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13163 where
13164 D: serde::Deserializer<'de>,
13165 {
13166 const FIELDS: &[&str] = &[
13167 ];
13168
13169 #[allow(clippy::enum_variant_names)]
13170 enum GeneratedField {
13171 }
13172 impl<'de> serde::Deserialize<'de> for GeneratedField {
13173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13174 where
13175 D: serde::Deserializer<'de>,
13176 {
13177 struct GeneratedVisitor;
13178
13179 impl serde::de::Visitor<'_> for GeneratedVisitor {
13180 type Value = GeneratedField;
13181
13182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13183 write!(formatter, "expected one of: {:?}", &FIELDS)
13184 }
13185
13186 #[allow(unused_variables)]
13187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13188 where
13189 E: serde::de::Error,
13190 {
13191 Err(serde::de::Error::unknown_field(value, FIELDS))
13192 }
13193 }
13194 deserializer.deserialize_identifier(GeneratedVisitor)
13195 }
13196 }
13197 struct GeneratedVisitor;
13198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13199 type Value = RiseCtlResumeVersionCheckpointResponse;
13200
13201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13202 formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
13203 }
13204
13205 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
13206 where
13207 V: serde::de::MapAccess<'de>,
13208 {
13209 while map_.next_key::<GeneratedField>()?.is_some() {
13210 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13211 }
13212 Ok(RiseCtlResumeVersionCheckpointResponse {
13213 })
13214 }
13215 }
13216 deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
13217 }
13218}
13219impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
13220 #[allow(deprecated)]
13221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13222 where
13223 S: serde::Serializer,
13224 {
13225 use serde::ser::SerializeStruct;
13226 let mut len = 0;
13227 if !self.compaction_group_ids.is_empty() {
13228 len += 1;
13229 }
13230 if !self.configs.is_empty() {
13231 len += 1;
13232 }
13233 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
13234 if !self.compaction_group_ids.is_empty() {
13235 struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
13236 }
13237 if !self.configs.is_empty() {
13238 struct_ser.serialize_field("configs", &self.configs)?;
13239 }
13240 struct_ser.end()
13241 }
13242}
13243impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
13244 #[allow(deprecated)]
13245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13246 where
13247 D: serde::Deserializer<'de>,
13248 {
13249 const FIELDS: &[&str] = &[
13250 "compaction_group_ids",
13251 "compactionGroupIds",
13252 "configs",
13253 ];
13254
13255 #[allow(clippy::enum_variant_names)]
13256 enum GeneratedField {
13257 CompactionGroupIds,
13258 Configs,
13259 }
13260 impl<'de> serde::Deserialize<'de> for GeneratedField {
13261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13262 where
13263 D: serde::Deserializer<'de>,
13264 {
13265 struct GeneratedVisitor;
13266
13267 impl serde::de::Visitor<'_> for GeneratedVisitor {
13268 type Value = GeneratedField;
13269
13270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13271 write!(formatter, "expected one of: {:?}", &FIELDS)
13272 }
13273
13274 #[allow(unused_variables)]
13275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13276 where
13277 E: serde::de::Error,
13278 {
13279 match value {
13280 "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
13281 "configs" => Ok(GeneratedField::Configs),
13282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13283 }
13284 }
13285 }
13286 deserializer.deserialize_identifier(GeneratedVisitor)
13287 }
13288 }
13289 struct GeneratedVisitor;
13290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13291 type Value = RiseCtlUpdateCompactionConfigRequest;
13292
13293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13294 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
13295 }
13296
13297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
13298 where
13299 V: serde::de::MapAccess<'de>,
13300 {
13301 let mut compaction_group_ids__ = None;
13302 let mut configs__ = None;
13303 while let Some(k) = map_.next_key()? {
13304 match k {
13305 GeneratedField::CompactionGroupIds => {
13306 if compaction_group_ids__.is_some() {
13307 return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
13308 }
13309 compaction_group_ids__ =
13310 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13311 .into_iter().map(|x| x.0).collect())
13312 ;
13313 }
13314 GeneratedField::Configs => {
13315 if configs__.is_some() {
13316 return Err(serde::de::Error::duplicate_field("configs"));
13317 }
13318 configs__ = Some(map_.next_value()?);
13319 }
13320 }
13321 }
13322 Ok(RiseCtlUpdateCompactionConfigRequest {
13323 compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
13324 configs: configs__.unwrap_or_default(),
13325 })
13326 }
13327 }
13328 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
13329 }
13330}
13331impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
13332 #[allow(deprecated)]
13333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13334 where
13335 S: serde::Serializer,
13336 {
13337 use serde::ser::SerializeStruct;
13338 let mut len = 0;
13339 if self.level != 0 {
13340 len += 1;
13341 }
13342 if !self.compression_algorithm.is_empty() {
13343 len += 1;
13344 }
13345 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
13346 if self.level != 0 {
13347 struct_ser.serialize_field("level", &self.level)?;
13348 }
13349 if !self.compression_algorithm.is_empty() {
13350 struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
13351 }
13352 struct_ser.end()
13353 }
13354}
13355impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
13356 #[allow(deprecated)]
13357 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13358 where
13359 D: serde::Deserializer<'de>,
13360 {
13361 const FIELDS: &[&str] = &[
13362 "level",
13363 "compression_algorithm",
13364 "compressionAlgorithm",
13365 ];
13366
13367 #[allow(clippy::enum_variant_names)]
13368 enum GeneratedField {
13369 Level,
13370 CompressionAlgorithm,
13371 }
13372 impl<'de> serde::Deserialize<'de> for GeneratedField {
13373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13374 where
13375 D: serde::Deserializer<'de>,
13376 {
13377 struct GeneratedVisitor;
13378
13379 impl serde::de::Visitor<'_> for GeneratedVisitor {
13380 type Value = GeneratedField;
13381
13382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13383 write!(formatter, "expected one of: {:?}", &FIELDS)
13384 }
13385
13386 #[allow(unused_variables)]
13387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13388 where
13389 E: serde::de::Error,
13390 {
13391 match value {
13392 "level" => Ok(GeneratedField::Level),
13393 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
13394 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13395 }
13396 }
13397 }
13398 deserializer.deserialize_identifier(GeneratedVisitor)
13399 }
13400 }
13401 struct GeneratedVisitor;
13402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13403 type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
13404
13405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13406 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
13407 }
13408
13409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
13410 where
13411 V: serde::de::MapAccess<'de>,
13412 {
13413 let mut level__ = None;
13414 let mut compression_algorithm__ = None;
13415 while let Some(k) = map_.next_key()? {
13416 match k {
13417 GeneratedField::Level => {
13418 if level__.is_some() {
13419 return Err(serde::de::Error::duplicate_field("level"));
13420 }
13421 level__ =
13422 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13423 ;
13424 }
13425 GeneratedField::CompressionAlgorithm => {
13426 if compression_algorithm__.is_some() {
13427 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13428 }
13429 compression_algorithm__ = Some(map_.next_value()?);
13430 }
13431 }
13432 }
13433 Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
13434 level: level__.unwrap_or_default(),
13435 compression_algorithm: compression_algorithm__.unwrap_or_default(),
13436 })
13437 }
13438 }
13439 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
13440 }
13441}
13442impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
13443 #[allow(deprecated)]
13444 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13445 where
13446 S: serde::Serializer,
13447 {
13448 use serde::ser::SerializeStruct;
13449 let mut len = 0;
13450 if self.mutable_config.is_some() {
13451 len += 1;
13452 }
13453 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
13454 if let Some(v) = self.mutable_config.as_ref() {
13455 match v {
13456 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
13457 #[allow(clippy::needless_borrow)]
13458 #[allow(clippy::needless_borrows_for_generic_args)]
13459 struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
13460 }
13461 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
13462 #[allow(clippy::needless_borrow)]
13463 #[allow(clippy::needless_borrows_for_generic_args)]
13464 struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
13465 }
13466 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
13467 #[allow(clippy::needless_borrow)]
13468 #[allow(clippy::needless_borrows_for_generic_args)]
13469 struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
13470 }
13471 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
13472 #[allow(clippy::needless_borrow)]
13473 #[allow(clippy::needless_borrows_for_generic_args)]
13474 struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
13475 }
13476 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
13477 #[allow(clippy::needless_borrow)]
13478 #[allow(clippy::needless_borrows_for_generic_args)]
13479 struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
13480 }
13481 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
13482 #[allow(clippy::needless_borrow)]
13483 #[allow(clippy::needless_borrows_for_generic_args)]
13484 struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
13485 }
13486 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
13487 struct_ser.serialize_field("compactionFilterMask", v)?;
13488 }
13489 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
13490 struct_ser.serialize_field("maxSubCompaction", v)?;
13491 }
13492 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
13493 #[allow(clippy::needless_borrow)]
13494 #[allow(clippy::needless_borrows_for_generic_args)]
13495 struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
13496 }
13497 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
13498 struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
13499 }
13500 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
13501 struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
13502 }
13503 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
13504 #[allow(clippy::needless_borrow)]
13505 #[allow(clippy::needless_borrows_for_generic_args)]
13506 struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
13507 }
13508 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
13509 #[allow(clippy::needless_borrow)]
13510 #[allow(clippy::needless_borrows_for_generic_args)]
13511 struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
13512 }
13513 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
13514 struct_ser.serialize_field("enableEmergencyPicker", v)?;
13515 }
13516 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
13517 struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
13518 }
13519 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
13520 struct_ser.serialize_field("compressionAlgorithm", v)?;
13521 }
13522 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
13523 struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
13524 }
13525 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
13526 #[allow(clippy::needless_borrow)]
13527 #[allow(clippy::needless_borrows_for_generic_args)]
13528 struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
13529 }
13530 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
13531 struct_ser.serialize_field("splitWeightByVnode", v)?;
13532 }
13533 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
13534 struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
13535 }
13536 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
13537 #[allow(clippy::needless_borrow)]
13538 #[allow(clippy::needless_borrows_for_generic_args)]
13539 struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
13540 }
13541 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
13542 struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
13543 }
13544 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
13545 struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
13546 }
13547 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
13548 struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
13549 }
13550 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
13551 #[allow(clippy::needless_borrow)]
13552 #[allow(clippy::needless_borrows_for_generic_args)]
13553 struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
13554 }
13555 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
13556 struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
13557 }
13558 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
13559 struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
13560 }
13561 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::VnodeAlignedLevelSizeThreshold(v) => {
13562 #[allow(clippy::needless_borrow)]
13563 #[allow(clippy::needless_borrows_for_generic_args)]
13564 struct_ser.serialize_field("vnodeAlignedLevelSizeThreshold", ToString::to_string(&v).as_str())?;
13565 }
13566 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxKvCountForXor16(v) => {
13567 #[allow(clippy::needless_borrow)]
13568 #[allow(clippy::needless_borrows_for_generic_args)]
13569 struct_ser.serialize_field("maxKvCountForXor16", ToString::to_string(&v).as_str())?;
13570 }
13571 rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxVnodeKeyRangeBytes(v) => {
13572 #[allow(clippy::needless_borrow)]
13573 #[allow(clippy::needless_borrows_for_generic_args)]
13574 struct_ser.serialize_field("maxVnodeKeyRangeBytes", ToString::to_string(&v).as_str())?;
13575 }
13576 }
13577 }
13578 struct_ser.end()
13579 }
13580}
13581impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
13582 #[allow(deprecated)]
13583 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13584 where
13585 D: serde::Deserializer<'de>,
13586 {
13587 const FIELDS: &[&str] = &[
13588 "max_bytes_for_level_base",
13589 "maxBytesForLevelBase",
13590 "max_bytes_for_level_multiplier",
13591 "maxBytesForLevelMultiplier",
13592 "max_compaction_bytes",
13593 "maxCompactionBytes",
13594 "sub_level_max_compaction_bytes",
13595 "subLevelMaxCompactionBytes",
13596 "level0_tier_compact_file_number",
13597 "level0TierCompactFileNumber",
13598 "target_file_size_base",
13599 "targetFileSizeBase",
13600 "compaction_filter_mask",
13601 "compactionFilterMask",
13602 "max_sub_compaction",
13603 "maxSubCompaction",
13604 "level0_stop_write_threshold_sub_level_number",
13605 "level0StopWriteThresholdSubLevelNumber",
13606 "level0_sub_level_compact_level_count",
13607 "level0SubLevelCompactLevelCount",
13608 "level0_overlapping_sub_level_compact_level_count",
13609 "level0OverlappingSubLevelCompactLevelCount",
13610 "max_space_reclaim_bytes",
13611 "maxSpaceReclaimBytes",
13612 "level0_max_compact_file_number",
13613 "level0MaxCompactFileNumber",
13614 "enable_emergency_picker",
13615 "enableEmergencyPicker",
13616 "tombstone_reclaim_ratio",
13617 "tombstoneReclaimRatio",
13618 "compression_algorithm",
13619 "compressionAlgorithm",
13620 "max_l0_compact_level_count",
13621 "maxL0CompactLevelCount",
13622 "sst_allowed_trivial_move_min_size",
13623 "sstAllowedTrivialMoveMinSize",
13624 "split_weight_by_vnode",
13625 "splitWeightByVnode",
13626 "disable_auto_group_scheduling",
13627 "disableAutoGroupScheduling",
13628 "max_overlapping_level_size",
13629 "maxOverlappingLevelSize",
13630 "emergency_level0_sst_file_count",
13631 "emergencyLevel0SstFileCount",
13632 "emergency_level0_sub_level_partition",
13633 "emergencyLevel0SubLevelPartition",
13634 "level0_stop_write_threshold_max_sst_count",
13635 "level0StopWriteThresholdMaxSstCount",
13636 "level0_stop_write_threshold_max_size",
13637 "level0StopWriteThresholdMaxSize",
13638 "sst_allowed_trivial_move_max_count",
13639 "sstAllowedTrivialMoveMaxCount",
13640 "enable_optimize_l0_interval_selection",
13641 "enableOptimizeL0IntervalSelection",
13642 "vnode_aligned_level_size_threshold",
13643 "vnodeAlignedLevelSizeThreshold",
13644 "max_kv_count_for_xor16",
13645 "maxKvCountForXor16",
13646 "max_vnode_key_range_bytes",
13647 "maxVnodeKeyRangeBytes",
13648 ];
13649
13650 #[allow(clippy::enum_variant_names)]
13651 enum GeneratedField {
13652 MaxBytesForLevelBase,
13653 MaxBytesForLevelMultiplier,
13654 MaxCompactionBytes,
13655 SubLevelMaxCompactionBytes,
13656 Level0TierCompactFileNumber,
13657 TargetFileSizeBase,
13658 CompactionFilterMask,
13659 MaxSubCompaction,
13660 Level0StopWriteThresholdSubLevelNumber,
13661 Level0SubLevelCompactLevelCount,
13662 Level0OverlappingSubLevelCompactLevelCount,
13663 MaxSpaceReclaimBytes,
13664 Level0MaxCompactFileNumber,
13665 EnableEmergencyPicker,
13666 TombstoneReclaimRatio,
13667 CompressionAlgorithm,
13668 MaxL0CompactLevelCount,
13669 SstAllowedTrivialMoveMinSize,
13670 SplitWeightByVnode,
13671 DisableAutoGroupScheduling,
13672 MaxOverlappingLevelSize,
13673 EmergencyLevel0SstFileCount,
13674 EmergencyLevel0SubLevelPartition,
13675 Level0StopWriteThresholdMaxSstCount,
13676 Level0StopWriteThresholdMaxSize,
13677 SstAllowedTrivialMoveMaxCount,
13678 EnableOptimizeL0IntervalSelection,
13679 VnodeAlignedLevelSizeThreshold,
13680 MaxKvCountForXor16,
13681 MaxVnodeKeyRangeBytes,
13682 }
13683 impl<'de> serde::Deserialize<'de> for GeneratedField {
13684 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13685 where
13686 D: serde::Deserializer<'de>,
13687 {
13688 struct GeneratedVisitor;
13689
13690 impl serde::de::Visitor<'_> for GeneratedVisitor {
13691 type Value = GeneratedField;
13692
13693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13694 write!(formatter, "expected one of: {:?}", &FIELDS)
13695 }
13696
13697 #[allow(unused_variables)]
13698 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13699 where
13700 E: serde::de::Error,
13701 {
13702 match value {
13703 "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
13704 "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
13705 "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
13706 "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
13707 "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
13708 "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
13709 "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
13710 "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
13711 "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
13712 "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
13713 "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
13714 "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
13715 "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
13716 "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
13717 "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
13718 "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
13719 "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
13720 "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
13721 "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
13722 "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
13723 "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
13724 "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
13725 "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
13726 "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
13727 "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
13728 "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
13729 "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
13730 "vnodeAlignedLevelSizeThreshold" | "vnode_aligned_level_size_threshold" => Ok(GeneratedField::VnodeAlignedLevelSizeThreshold),
13731 "maxKvCountForXor16" | "max_kv_count_for_xor16" => Ok(GeneratedField::MaxKvCountForXor16),
13732 "maxVnodeKeyRangeBytes" | "max_vnode_key_range_bytes" => Ok(GeneratedField::MaxVnodeKeyRangeBytes),
13733 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13734 }
13735 }
13736 }
13737 deserializer.deserialize_identifier(GeneratedVisitor)
13738 }
13739 }
13740 struct GeneratedVisitor;
13741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13742 type Value = rise_ctl_update_compaction_config_request::MutableConfig;
13743
13744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13745 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
13746 }
13747
13748 fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
13749 where
13750 V: serde::de::MapAccess<'de>,
13751 {
13752 let mut mutable_config__ = None;
13753 while let Some(k) = map_.next_key()? {
13754 match k {
13755 GeneratedField::MaxBytesForLevelBase => {
13756 if mutable_config__.is_some() {
13757 return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
13758 }
13759 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));
13760 }
13761 GeneratedField::MaxBytesForLevelMultiplier => {
13762 if mutable_config__.is_some() {
13763 return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
13764 }
13765 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));
13766 }
13767 GeneratedField::MaxCompactionBytes => {
13768 if mutable_config__.is_some() {
13769 return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
13770 }
13771 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));
13772 }
13773 GeneratedField::SubLevelMaxCompactionBytes => {
13774 if mutable_config__.is_some() {
13775 return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
13776 }
13777 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));
13778 }
13779 GeneratedField::Level0TierCompactFileNumber => {
13780 if mutable_config__.is_some() {
13781 return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
13782 }
13783 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));
13784 }
13785 GeneratedField::TargetFileSizeBase => {
13786 if mutable_config__.is_some() {
13787 return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
13788 }
13789 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));
13790 }
13791 GeneratedField::CompactionFilterMask => {
13792 if mutable_config__.is_some() {
13793 return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
13794 }
13795 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));
13796 }
13797 GeneratedField::MaxSubCompaction => {
13798 if mutable_config__.is_some() {
13799 return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
13800 }
13801 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));
13802 }
13803 GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
13804 if mutable_config__.is_some() {
13805 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
13806 }
13807 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));
13808 }
13809 GeneratedField::Level0SubLevelCompactLevelCount => {
13810 if mutable_config__.is_some() {
13811 return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
13812 }
13813 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));
13814 }
13815 GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
13816 if mutable_config__.is_some() {
13817 return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
13818 }
13819 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));
13820 }
13821 GeneratedField::MaxSpaceReclaimBytes => {
13822 if mutable_config__.is_some() {
13823 return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
13824 }
13825 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));
13826 }
13827 GeneratedField::Level0MaxCompactFileNumber => {
13828 if mutable_config__.is_some() {
13829 return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
13830 }
13831 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));
13832 }
13833 GeneratedField::EnableEmergencyPicker => {
13834 if mutable_config__.is_some() {
13835 return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
13836 }
13837 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
13838 }
13839 GeneratedField::TombstoneReclaimRatio => {
13840 if mutable_config__.is_some() {
13841 return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
13842 }
13843 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));
13844 }
13845 GeneratedField::CompressionAlgorithm => {
13846 if mutable_config__.is_some() {
13847 return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13848 }
13849 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
13850;
13851 }
13852 GeneratedField::MaxL0CompactLevelCount => {
13853 if mutable_config__.is_some() {
13854 return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
13855 }
13856 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));
13857 }
13858 GeneratedField::SstAllowedTrivialMoveMinSize => {
13859 if mutable_config__.is_some() {
13860 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
13861 }
13862 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));
13863 }
13864 GeneratedField::SplitWeightByVnode => {
13865 if mutable_config__.is_some() {
13866 return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
13867 }
13868 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));
13869 }
13870 GeneratedField::DisableAutoGroupScheduling => {
13871 if mutable_config__.is_some() {
13872 return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
13873 }
13874 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
13875 }
13876 GeneratedField::MaxOverlappingLevelSize => {
13877 if mutable_config__.is_some() {
13878 return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
13879 }
13880 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));
13881 }
13882 GeneratedField::EmergencyLevel0SstFileCount => {
13883 if mutable_config__.is_some() {
13884 return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
13885 }
13886 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));
13887 }
13888 GeneratedField::EmergencyLevel0SubLevelPartition => {
13889 if mutable_config__.is_some() {
13890 return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
13891 }
13892 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));
13893 }
13894 GeneratedField::Level0StopWriteThresholdMaxSstCount => {
13895 if mutable_config__.is_some() {
13896 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
13897 }
13898 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));
13899 }
13900 GeneratedField::Level0StopWriteThresholdMaxSize => {
13901 if mutable_config__.is_some() {
13902 return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
13903 }
13904 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));
13905 }
13906 GeneratedField::SstAllowedTrivialMoveMaxCount => {
13907 if mutable_config__.is_some() {
13908 return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
13909 }
13910 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));
13911 }
13912 GeneratedField::EnableOptimizeL0IntervalSelection => {
13913 if mutable_config__.is_some() {
13914 return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
13915 }
13916 mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
13917 }
13918 GeneratedField::VnodeAlignedLevelSizeThreshold => {
13919 if mutable_config__.is_some() {
13920 return Err(serde::de::Error::duplicate_field("vnodeAlignedLevelSizeThreshold"));
13921 }
13922 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));
13923 }
13924 GeneratedField::MaxKvCountForXor16 => {
13925 if mutable_config__.is_some() {
13926 return Err(serde::de::Error::duplicate_field("maxKvCountForXor16"));
13927 }
13928 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));
13929 }
13930 GeneratedField::MaxVnodeKeyRangeBytes => {
13931 if mutable_config__.is_some() {
13932 return Err(serde::de::Error::duplicate_field("maxVnodeKeyRangeBytes"));
13933 }
13934 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));
13935 }
13936 }
13937 }
13938 Ok(rise_ctl_update_compaction_config_request::MutableConfig {
13939 mutable_config: mutable_config__,
13940 })
13941 }
13942 }
13943 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
13944 }
13945}
13946impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
13947 #[allow(deprecated)]
13948 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13949 where
13950 S: serde::Serializer,
13951 {
13952 use serde::ser::SerializeStruct;
13953 let mut len = 0;
13954 if self.status.is_some() {
13955 len += 1;
13956 }
13957 let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
13958 if let Some(v) = self.status.as_ref() {
13959 struct_ser.serialize_field("status", v)?;
13960 }
13961 struct_ser.end()
13962 }
13963}
13964impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
13965 #[allow(deprecated)]
13966 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13967 where
13968 D: serde::Deserializer<'de>,
13969 {
13970 const FIELDS: &[&str] = &[
13971 "status",
13972 ];
13973
13974 #[allow(clippy::enum_variant_names)]
13975 enum GeneratedField {
13976 Status,
13977 }
13978 impl<'de> serde::Deserialize<'de> for GeneratedField {
13979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13980 where
13981 D: serde::Deserializer<'de>,
13982 {
13983 struct GeneratedVisitor;
13984
13985 impl serde::de::Visitor<'_> for GeneratedVisitor {
13986 type Value = GeneratedField;
13987
13988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13989 write!(formatter, "expected one of: {:?}", &FIELDS)
13990 }
13991
13992 #[allow(unused_variables)]
13993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13994 where
13995 E: serde::de::Error,
13996 {
13997 match value {
13998 "status" => Ok(GeneratedField::Status),
13999 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14000 }
14001 }
14002 }
14003 deserializer.deserialize_identifier(GeneratedVisitor)
14004 }
14005 }
14006 struct GeneratedVisitor;
14007 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14008 type Value = RiseCtlUpdateCompactionConfigResponse;
14009
14010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14011 formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
14012 }
14013
14014 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
14015 where
14016 V: serde::de::MapAccess<'de>,
14017 {
14018 let mut status__ = None;
14019 while let Some(k) = map_.next_key()? {
14020 match k {
14021 GeneratedField::Status => {
14022 if status__.is_some() {
14023 return Err(serde::de::Error::duplicate_field("status"));
14024 }
14025 status__ = map_.next_value()?;
14026 }
14027 }
14028 }
14029 Ok(RiseCtlUpdateCompactionConfigResponse {
14030 status: status__,
14031 })
14032 }
14033 }
14034 deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
14035 }
14036}
14037impl serde::Serialize for SplitCompactionGroupRequest {
14038 #[allow(deprecated)]
14039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14040 where
14041 S: serde::Serializer,
14042 {
14043 use serde::ser::SerializeStruct;
14044 let mut len = 0;
14045 if self.group_id != 0 {
14046 len += 1;
14047 }
14048 if !self.table_ids.is_empty() {
14049 len += 1;
14050 }
14051 if self.partition_vnode_count != 0 {
14052 len += 1;
14053 }
14054 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
14055 if self.group_id != 0 {
14056 #[allow(clippy::needless_borrow)]
14057 #[allow(clippy::needless_borrows_for_generic_args)]
14058 struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
14059 }
14060 if !self.table_ids.is_empty() {
14061 struct_ser.serialize_field("tableIds", &self.table_ids)?;
14062 }
14063 if self.partition_vnode_count != 0 {
14064 struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
14065 }
14066 struct_ser.end()
14067 }
14068}
14069impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
14070 #[allow(deprecated)]
14071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14072 where
14073 D: serde::Deserializer<'de>,
14074 {
14075 const FIELDS: &[&str] = &[
14076 "group_id",
14077 "groupId",
14078 "table_ids",
14079 "tableIds",
14080 "partition_vnode_count",
14081 "partitionVnodeCount",
14082 ];
14083
14084 #[allow(clippy::enum_variant_names)]
14085 enum GeneratedField {
14086 GroupId,
14087 TableIds,
14088 PartitionVnodeCount,
14089 }
14090 impl<'de> serde::Deserialize<'de> for GeneratedField {
14091 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14092 where
14093 D: serde::Deserializer<'de>,
14094 {
14095 struct GeneratedVisitor;
14096
14097 impl serde::de::Visitor<'_> for GeneratedVisitor {
14098 type Value = GeneratedField;
14099
14100 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14101 write!(formatter, "expected one of: {:?}", &FIELDS)
14102 }
14103
14104 #[allow(unused_variables)]
14105 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14106 where
14107 E: serde::de::Error,
14108 {
14109 match value {
14110 "groupId" | "group_id" => Ok(GeneratedField::GroupId),
14111 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
14112 "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
14113 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14114 }
14115 }
14116 }
14117 deserializer.deserialize_identifier(GeneratedVisitor)
14118 }
14119 }
14120 struct GeneratedVisitor;
14121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14122 type Value = SplitCompactionGroupRequest;
14123
14124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14125 formatter.write_str("struct hummock.SplitCompactionGroupRequest")
14126 }
14127
14128 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
14129 where
14130 V: serde::de::MapAccess<'de>,
14131 {
14132 let mut group_id__ = None;
14133 let mut table_ids__ = None;
14134 let mut partition_vnode_count__ = None;
14135 while let Some(k) = map_.next_key()? {
14136 match k {
14137 GeneratedField::GroupId => {
14138 if group_id__.is_some() {
14139 return Err(serde::de::Error::duplicate_field("groupId"));
14140 }
14141 group_id__ =
14142 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14143 ;
14144 }
14145 GeneratedField::TableIds => {
14146 if table_ids__.is_some() {
14147 return Err(serde::de::Error::duplicate_field("tableIds"));
14148 }
14149 table_ids__ =
14150 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14151 .into_iter().map(|x| x.0).collect())
14152 ;
14153 }
14154 GeneratedField::PartitionVnodeCount => {
14155 if partition_vnode_count__.is_some() {
14156 return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
14157 }
14158 partition_vnode_count__ =
14159 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14160 ;
14161 }
14162 }
14163 }
14164 Ok(SplitCompactionGroupRequest {
14165 group_id: group_id__.unwrap_or_default(),
14166 table_ids: table_ids__.unwrap_or_default(),
14167 partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
14168 })
14169 }
14170 }
14171 deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
14172 }
14173}
14174impl serde::Serialize for SplitCompactionGroupResponse {
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.new_group_id != 0 {
14183 len += 1;
14184 }
14185 let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
14186 if self.new_group_id != 0 {
14187 #[allow(clippy::needless_borrow)]
14188 #[allow(clippy::needless_borrows_for_generic_args)]
14189 struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
14190 }
14191 struct_ser.end()
14192 }
14193}
14194impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
14195 #[allow(deprecated)]
14196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14197 where
14198 D: serde::Deserializer<'de>,
14199 {
14200 const FIELDS: &[&str] = &[
14201 "new_group_id",
14202 "newGroupId",
14203 ];
14204
14205 #[allow(clippy::enum_variant_names)]
14206 enum GeneratedField {
14207 NewGroupId,
14208 }
14209 impl<'de> serde::Deserialize<'de> for GeneratedField {
14210 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14211 where
14212 D: serde::Deserializer<'de>,
14213 {
14214 struct GeneratedVisitor;
14215
14216 impl serde::de::Visitor<'_> for GeneratedVisitor {
14217 type Value = GeneratedField;
14218
14219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14220 write!(formatter, "expected one of: {:?}", &FIELDS)
14221 }
14222
14223 #[allow(unused_variables)]
14224 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14225 where
14226 E: serde::de::Error,
14227 {
14228 match value {
14229 "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
14230 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14231 }
14232 }
14233 }
14234 deserializer.deserialize_identifier(GeneratedVisitor)
14235 }
14236 }
14237 struct GeneratedVisitor;
14238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14239 type Value = SplitCompactionGroupResponse;
14240
14241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14242 formatter.write_str("struct hummock.SplitCompactionGroupResponse")
14243 }
14244
14245 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
14246 where
14247 V: serde::de::MapAccess<'de>,
14248 {
14249 let mut new_group_id__ = None;
14250 while let Some(k) = map_.next_key()? {
14251 match k {
14252 GeneratedField::NewGroupId => {
14253 if new_group_id__.is_some() {
14254 return Err(serde::de::Error::duplicate_field("newGroupId"));
14255 }
14256 new_group_id__ =
14257 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14258 ;
14259 }
14260 }
14261 }
14262 Ok(SplitCompactionGroupResponse {
14263 new_group_id: new_group_id__.unwrap_or_default(),
14264 })
14265 }
14266 }
14267 deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
14268 }
14269}
14270impl serde::Serialize for SstableInfo {
14271 #[allow(deprecated)]
14272 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14273 where
14274 S: serde::Serializer,
14275 {
14276 use serde::ser::SerializeStruct;
14277 let mut len = 0;
14278 if self.object_id != 0 {
14279 len += 1;
14280 }
14281 if self.sst_id != 0 {
14282 len += 1;
14283 }
14284 if self.key_range.is_some() {
14285 len += 1;
14286 }
14287 if self.file_size != 0 {
14288 len += 1;
14289 }
14290 if !self.table_ids.is_empty() {
14291 len += 1;
14292 }
14293 if self.meta_offset != 0 {
14294 len += 1;
14295 }
14296 if self.stale_key_count != 0 {
14297 len += 1;
14298 }
14299 if self.total_key_count != 0 {
14300 len += 1;
14301 }
14302 if self.min_epoch != 0 {
14303 len += 1;
14304 }
14305 if self.max_epoch != 0 {
14306 len += 1;
14307 }
14308 if self.uncompressed_file_size != 0 {
14309 len += 1;
14310 }
14311 if self.range_tombstone_count != 0 {
14312 len += 1;
14313 }
14314 if self.bloom_filter_kind != 0 {
14315 len += 1;
14316 }
14317 if self.sst_size != 0 {
14318 len += 1;
14319 }
14320 if self.vnode_statistics.is_some() {
14321 len += 1;
14322 }
14323 let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
14324 if self.object_id != 0 {
14325 #[allow(clippy::needless_borrow)]
14326 #[allow(clippy::needless_borrows_for_generic_args)]
14327 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
14328 }
14329 if self.sst_id != 0 {
14330 #[allow(clippy::needless_borrow)]
14331 #[allow(clippy::needless_borrows_for_generic_args)]
14332 struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
14333 }
14334 if let Some(v) = self.key_range.as_ref() {
14335 struct_ser.serialize_field("keyRange", v)?;
14336 }
14337 if self.file_size != 0 {
14338 #[allow(clippy::needless_borrow)]
14339 #[allow(clippy::needless_borrows_for_generic_args)]
14340 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
14341 }
14342 if !self.table_ids.is_empty() {
14343 struct_ser.serialize_field("tableIds", &self.table_ids)?;
14344 }
14345 if self.meta_offset != 0 {
14346 #[allow(clippy::needless_borrow)]
14347 #[allow(clippy::needless_borrows_for_generic_args)]
14348 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
14349 }
14350 if self.stale_key_count != 0 {
14351 #[allow(clippy::needless_borrow)]
14352 #[allow(clippy::needless_borrows_for_generic_args)]
14353 struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
14354 }
14355 if self.total_key_count != 0 {
14356 #[allow(clippy::needless_borrow)]
14357 #[allow(clippy::needless_borrows_for_generic_args)]
14358 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
14359 }
14360 if self.min_epoch != 0 {
14361 #[allow(clippy::needless_borrow)]
14362 #[allow(clippy::needless_borrows_for_generic_args)]
14363 struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
14364 }
14365 if self.max_epoch != 0 {
14366 #[allow(clippy::needless_borrow)]
14367 #[allow(clippy::needless_borrows_for_generic_args)]
14368 struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
14369 }
14370 if self.uncompressed_file_size != 0 {
14371 #[allow(clippy::needless_borrow)]
14372 #[allow(clippy::needless_borrows_for_generic_args)]
14373 struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
14374 }
14375 if self.range_tombstone_count != 0 {
14376 #[allow(clippy::needless_borrow)]
14377 #[allow(clippy::needless_borrows_for_generic_args)]
14378 struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
14379 }
14380 if self.bloom_filter_kind != 0 {
14381 let v = BloomFilterType::try_from(self.bloom_filter_kind)
14382 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
14383 struct_ser.serialize_field("bloomFilterKind", &v)?;
14384 }
14385 if self.sst_size != 0 {
14386 #[allow(clippy::needless_borrow)]
14387 #[allow(clippy::needless_borrows_for_generic_args)]
14388 struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
14389 }
14390 if let Some(v) = self.vnode_statistics.as_ref() {
14391 struct_ser.serialize_field("vnodeStatistics", v)?;
14392 }
14393 struct_ser.end()
14394 }
14395}
14396impl<'de> serde::Deserialize<'de> for SstableInfo {
14397 #[allow(deprecated)]
14398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14399 where
14400 D: serde::Deserializer<'de>,
14401 {
14402 const FIELDS: &[&str] = &[
14403 "object_id",
14404 "objectId",
14405 "sst_id",
14406 "sstId",
14407 "key_range",
14408 "keyRange",
14409 "file_size",
14410 "fileSize",
14411 "table_ids",
14412 "tableIds",
14413 "meta_offset",
14414 "metaOffset",
14415 "stale_key_count",
14416 "staleKeyCount",
14417 "total_key_count",
14418 "totalKeyCount",
14419 "min_epoch",
14420 "minEpoch",
14421 "max_epoch",
14422 "maxEpoch",
14423 "uncompressed_file_size",
14424 "uncompressedFileSize",
14425 "range_tombstone_count",
14426 "rangeTombstoneCount",
14427 "bloom_filter_kind",
14428 "bloomFilterKind",
14429 "sst_size",
14430 "sstSize",
14431 "vnode_statistics",
14432 "vnodeStatistics",
14433 ];
14434
14435 #[allow(clippy::enum_variant_names)]
14436 enum GeneratedField {
14437 ObjectId,
14438 SstId,
14439 KeyRange,
14440 FileSize,
14441 TableIds,
14442 MetaOffset,
14443 StaleKeyCount,
14444 TotalKeyCount,
14445 MinEpoch,
14446 MaxEpoch,
14447 UncompressedFileSize,
14448 RangeTombstoneCount,
14449 BloomFilterKind,
14450 SstSize,
14451 VnodeStatistics,
14452 }
14453 impl<'de> serde::Deserialize<'de> for GeneratedField {
14454 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14455 where
14456 D: serde::Deserializer<'de>,
14457 {
14458 struct GeneratedVisitor;
14459
14460 impl serde::de::Visitor<'_> for GeneratedVisitor {
14461 type Value = GeneratedField;
14462
14463 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14464 write!(formatter, "expected one of: {:?}", &FIELDS)
14465 }
14466
14467 #[allow(unused_variables)]
14468 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14469 where
14470 E: serde::de::Error,
14471 {
14472 match value {
14473 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
14474 "sstId" | "sst_id" => Ok(GeneratedField::SstId),
14475 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
14476 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
14477 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
14478 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
14479 "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
14480 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
14481 "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
14482 "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
14483 "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
14484 "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
14485 "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
14486 "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
14487 "vnodeStatistics" | "vnode_statistics" => Ok(GeneratedField::VnodeStatistics),
14488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14489 }
14490 }
14491 }
14492 deserializer.deserialize_identifier(GeneratedVisitor)
14493 }
14494 }
14495 struct GeneratedVisitor;
14496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14497 type Value = SstableInfo;
14498
14499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14500 formatter.write_str("struct hummock.SstableInfo")
14501 }
14502
14503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
14504 where
14505 V: serde::de::MapAccess<'de>,
14506 {
14507 let mut object_id__ = None;
14508 let mut sst_id__ = None;
14509 let mut key_range__ = None;
14510 let mut file_size__ = None;
14511 let mut table_ids__ = None;
14512 let mut meta_offset__ = None;
14513 let mut stale_key_count__ = None;
14514 let mut total_key_count__ = None;
14515 let mut min_epoch__ = None;
14516 let mut max_epoch__ = None;
14517 let mut uncompressed_file_size__ = None;
14518 let mut range_tombstone_count__ = None;
14519 let mut bloom_filter_kind__ = None;
14520 let mut sst_size__ = None;
14521 let mut vnode_statistics__ = None;
14522 while let Some(k) = map_.next_key()? {
14523 match k {
14524 GeneratedField::ObjectId => {
14525 if object_id__.is_some() {
14526 return Err(serde::de::Error::duplicate_field("objectId"));
14527 }
14528 object_id__ =
14529 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14530 ;
14531 }
14532 GeneratedField::SstId => {
14533 if sst_id__.is_some() {
14534 return Err(serde::de::Error::duplicate_field("sstId"));
14535 }
14536 sst_id__ =
14537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14538 ;
14539 }
14540 GeneratedField::KeyRange => {
14541 if key_range__.is_some() {
14542 return Err(serde::de::Error::duplicate_field("keyRange"));
14543 }
14544 key_range__ = map_.next_value()?;
14545 }
14546 GeneratedField::FileSize => {
14547 if file_size__.is_some() {
14548 return Err(serde::de::Error::duplicate_field("fileSize"));
14549 }
14550 file_size__ =
14551 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14552 ;
14553 }
14554 GeneratedField::TableIds => {
14555 if table_ids__.is_some() {
14556 return Err(serde::de::Error::duplicate_field("tableIds"));
14557 }
14558 table_ids__ =
14559 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14560 .into_iter().map(|x| x.0).collect())
14561 ;
14562 }
14563 GeneratedField::MetaOffset => {
14564 if meta_offset__.is_some() {
14565 return Err(serde::de::Error::duplicate_field("metaOffset"));
14566 }
14567 meta_offset__ =
14568 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14569 ;
14570 }
14571 GeneratedField::StaleKeyCount => {
14572 if stale_key_count__.is_some() {
14573 return Err(serde::de::Error::duplicate_field("staleKeyCount"));
14574 }
14575 stale_key_count__ =
14576 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14577 ;
14578 }
14579 GeneratedField::TotalKeyCount => {
14580 if total_key_count__.is_some() {
14581 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
14582 }
14583 total_key_count__ =
14584 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14585 ;
14586 }
14587 GeneratedField::MinEpoch => {
14588 if min_epoch__.is_some() {
14589 return Err(serde::de::Error::duplicate_field("minEpoch"));
14590 }
14591 min_epoch__ =
14592 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14593 ;
14594 }
14595 GeneratedField::MaxEpoch => {
14596 if max_epoch__.is_some() {
14597 return Err(serde::de::Error::duplicate_field("maxEpoch"));
14598 }
14599 max_epoch__ =
14600 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14601 ;
14602 }
14603 GeneratedField::UncompressedFileSize => {
14604 if uncompressed_file_size__.is_some() {
14605 return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
14606 }
14607 uncompressed_file_size__ =
14608 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14609 ;
14610 }
14611 GeneratedField::RangeTombstoneCount => {
14612 if range_tombstone_count__.is_some() {
14613 return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
14614 }
14615 range_tombstone_count__ =
14616 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14617 ;
14618 }
14619 GeneratedField::BloomFilterKind => {
14620 if bloom_filter_kind__.is_some() {
14621 return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
14622 }
14623 bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
14624 }
14625 GeneratedField::SstSize => {
14626 if sst_size__.is_some() {
14627 return Err(serde::de::Error::duplicate_field("sstSize"));
14628 }
14629 sst_size__ =
14630 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14631 ;
14632 }
14633 GeneratedField::VnodeStatistics => {
14634 if vnode_statistics__.is_some() {
14635 return Err(serde::de::Error::duplicate_field("vnodeStatistics"));
14636 }
14637 vnode_statistics__ = map_.next_value()?;
14638 }
14639 }
14640 }
14641 Ok(SstableInfo {
14642 object_id: object_id__.unwrap_or_default(),
14643 sst_id: sst_id__.unwrap_or_default(),
14644 key_range: key_range__,
14645 file_size: file_size__.unwrap_or_default(),
14646 table_ids: table_ids__.unwrap_or_default(),
14647 meta_offset: meta_offset__.unwrap_or_default(),
14648 stale_key_count: stale_key_count__.unwrap_or_default(),
14649 total_key_count: total_key_count__.unwrap_or_default(),
14650 min_epoch: min_epoch__.unwrap_or_default(),
14651 max_epoch: max_epoch__.unwrap_or_default(),
14652 uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
14653 range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
14654 bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
14655 sst_size: sst_size__.unwrap_or_default(),
14656 vnode_statistics: vnode_statistics__,
14657 })
14658 }
14659 }
14660 deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
14661 }
14662}
14663impl serde::Serialize for StateTableInfo {
14664 #[allow(deprecated)]
14665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14666 where
14667 S: serde::Serializer,
14668 {
14669 use serde::ser::SerializeStruct;
14670 let mut len = 0;
14671 if self.committed_epoch != 0 {
14672 len += 1;
14673 }
14674 if self.compaction_group_id != 0 {
14675 len += 1;
14676 }
14677 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
14678 if self.committed_epoch != 0 {
14679 #[allow(clippy::needless_borrow)]
14680 #[allow(clippy::needless_borrows_for_generic_args)]
14681 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
14682 }
14683 if self.compaction_group_id != 0 {
14684 #[allow(clippy::needless_borrow)]
14685 #[allow(clippy::needless_borrows_for_generic_args)]
14686 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
14687 }
14688 struct_ser.end()
14689 }
14690}
14691impl<'de> serde::Deserialize<'de> for StateTableInfo {
14692 #[allow(deprecated)]
14693 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14694 where
14695 D: serde::Deserializer<'de>,
14696 {
14697 const FIELDS: &[&str] = &[
14698 "committed_epoch",
14699 "committedEpoch",
14700 "compaction_group_id",
14701 "compactionGroupId",
14702 ];
14703
14704 #[allow(clippy::enum_variant_names)]
14705 enum GeneratedField {
14706 CommittedEpoch,
14707 CompactionGroupId,
14708 }
14709 impl<'de> serde::Deserialize<'de> for GeneratedField {
14710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14711 where
14712 D: serde::Deserializer<'de>,
14713 {
14714 struct GeneratedVisitor;
14715
14716 impl serde::de::Visitor<'_> for GeneratedVisitor {
14717 type Value = GeneratedField;
14718
14719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14720 write!(formatter, "expected one of: {:?}", &FIELDS)
14721 }
14722
14723 #[allow(unused_variables)]
14724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14725 where
14726 E: serde::de::Error,
14727 {
14728 match value {
14729 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
14730 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
14731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14732 }
14733 }
14734 }
14735 deserializer.deserialize_identifier(GeneratedVisitor)
14736 }
14737 }
14738 struct GeneratedVisitor;
14739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14740 type Value = StateTableInfo;
14741
14742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14743 formatter.write_str("struct hummock.StateTableInfo")
14744 }
14745
14746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
14747 where
14748 V: serde::de::MapAccess<'de>,
14749 {
14750 let mut committed_epoch__ = None;
14751 let mut compaction_group_id__ = None;
14752 while let Some(k) = map_.next_key()? {
14753 match k {
14754 GeneratedField::CommittedEpoch => {
14755 if committed_epoch__.is_some() {
14756 return Err(serde::de::Error::duplicate_field("committedEpoch"));
14757 }
14758 committed_epoch__ =
14759 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14760 ;
14761 }
14762 GeneratedField::CompactionGroupId => {
14763 if compaction_group_id__.is_some() {
14764 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14765 }
14766 compaction_group_id__ =
14767 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14768 ;
14769 }
14770 }
14771 }
14772 Ok(StateTableInfo {
14773 committed_epoch: committed_epoch__.unwrap_or_default(),
14774 compaction_group_id: compaction_group_id__.unwrap_or_default(),
14775 })
14776 }
14777 }
14778 deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
14779 }
14780}
14781impl serde::Serialize for StateTableInfoDelta {
14782 #[allow(deprecated)]
14783 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14784 where
14785 S: serde::Serializer,
14786 {
14787 use serde::ser::SerializeStruct;
14788 let mut len = 0;
14789 if self.committed_epoch != 0 {
14790 len += 1;
14791 }
14792 if self.compaction_group_id != 0 {
14793 len += 1;
14794 }
14795 let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
14796 if self.committed_epoch != 0 {
14797 #[allow(clippy::needless_borrow)]
14798 #[allow(clippy::needless_borrows_for_generic_args)]
14799 struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
14800 }
14801 if self.compaction_group_id != 0 {
14802 #[allow(clippy::needless_borrow)]
14803 #[allow(clippy::needless_borrows_for_generic_args)]
14804 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
14805 }
14806 struct_ser.end()
14807 }
14808}
14809impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
14810 #[allow(deprecated)]
14811 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14812 where
14813 D: serde::Deserializer<'de>,
14814 {
14815 const FIELDS: &[&str] = &[
14816 "committed_epoch",
14817 "committedEpoch",
14818 "compaction_group_id",
14819 "compactionGroupId",
14820 ];
14821
14822 #[allow(clippy::enum_variant_names)]
14823 enum GeneratedField {
14824 CommittedEpoch,
14825 CompactionGroupId,
14826 }
14827 impl<'de> serde::Deserialize<'de> for GeneratedField {
14828 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14829 where
14830 D: serde::Deserializer<'de>,
14831 {
14832 struct GeneratedVisitor;
14833
14834 impl serde::de::Visitor<'_> for GeneratedVisitor {
14835 type Value = GeneratedField;
14836
14837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14838 write!(formatter, "expected one of: {:?}", &FIELDS)
14839 }
14840
14841 #[allow(unused_variables)]
14842 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14843 where
14844 E: serde::de::Error,
14845 {
14846 match value {
14847 "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
14848 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
14849 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14850 }
14851 }
14852 }
14853 deserializer.deserialize_identifier(GeneratedVisitor)
14854 }
14855 }
14856 struct GeneratedVisitor;
14857 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14858 type Value = StateTableInfoDelta;
14859
14860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14861 formatter.write_str("struct hummock.StateTableInfoDelta")
14862 }
14863
14864 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
14865 where
14866 V: serde::de::MapAccess<'de>,
14867 {
14868 let mut committed_epoch__ = None;
14869 let mut compaction_group_id__ = None;
14870 while let Some(k) = map_.next_key()? {
14871 match k {
14872 GeneratedField::CommittedEpoch => {
14873 if committed_epoch__.is_some() {
14874 return Err(serde::de::Error::duplicate_field("committedEpoch"));
14875 }
14876 committed_epoch__ =
14877 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14878 ;
14879 }
14880 GeneratedField::CompactionGroupId => {
14881 if compaction_group_id__.is_some() {
14882 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14883 }
14884 compaction_group_id__ =
14885 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14886 ;
14887 }
14888 }
14889 }
14890 Ok(StateTableInfoDelta {
14891 committed_epoch: committed_epoch__.unwrap_or_default(),
14892 compaction_group_id: compaction_group_id__.unwrap_or_default(),
14893 })
14894 }
14895 }
14896 deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
14897 }
14898}
14899impl serde::Serialize for SubscribeCompactionEventRequest {
14900 #[allow(deprecated)]
14901 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14902 where
14903 S: serde::Serializer,
14904 {
14905 use serde::ser::SerializeStruct;
14906 let mut len = 0;
14907 if self.create_at != 0 {
14908 len += 1;
14909 }
14910 if self.event.is_some() {
14911 len += 1;
14912 }
14913 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
14914 if self.create_at != 0 {
14915 #[allow(clippy::needless_borrow)]
14916 #[allow(clippy::needless_borrows_for_generic_args)]
14917 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14918 }
14919 if let Some(v) = self.event.as_ref() {
14920 match v {
14921 subscribe_compaction_event_request::Event::Register(v) => {
14922 struct_ser.serialize_field("register", v)?;
14923 }
14924 subscribe_compaction_event_request::Event::PullTask(v) => {
14925 struct_ser.serialize_field("pullTask", v)?;
14926 }
14927 subscribe_compaction_event_request::Event::ReportTask(v) => {
14928 struct_ser.serialize_field("reportTask", v)?;
14929 }
14930 subscribe_compaction_event_request::Event::HeartBeat(v) => {
14931 struct_ser.serialize_field("heartBeat", v)?;
14932 }
14933 }
14934 }
14935 struct_ser.end()
14936 }
14937}
14938impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
14939 #[allow(deprecated)]
14940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14941 where
14942 D: serde::Deserializer<'de>,
14943 {
14944 const FIELDS: &[&str] = &[
14945 "create_at",
14946 "createAt",
14947 "register",
14948 "pull_task",
14949 "pullTask",
14950 "report_task",
14951 "reportTask",
14952 "heart_beat",
14953 "heartBeat",
14954 ];
14955
14956 #[allow(clippy::enum_variant_names)]
14957 enum GeneratedField {
14958 CreateAt,
14959 Register,
14960 PullTask,
14961 ReportTask,
14962 HeartBeat,
14963 }
14964 impl<'de> serde::Deserialize<'de> for GeneratedField {
14965 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14966 where
14967 D: serde::Deserializer<'de>,
14968 {
14969 struct GeneratedVisitor;
14970
14971 impl serde::de::Visitor<'_> for GeneratedVisitor {
14972 type Value = GeneratedField;
14973
14974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14975 write!(formatter, "expected one of: {:?}", &FIELDS)
14976 }
14977
14978 #[allow(unused_variables)]
14979 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14980 where
14981 E: serde::de::Error,
14982 {
14983 match value {
14984 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14985 "register" => Ok(GeneratedField::Register),
14986 "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
14987 "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
14988 "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
14989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14990 }
14991 }
14992 }
14993 deserializer.deserialize_identifier(GeneratedVisitor)
14994 }
14995 }
14996 struct GeneratedVisitor;
14997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14998 type Value = SubscribeCompactionEventRequest;
14999
15000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15001 formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
15002 }
15003
15004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
15005 where
15006 V: serde::de::MapAccess<'de>,
15007 {
15008 let mut create_at__ = None;
15009 let mut event__ = None;
15010 while let Some(k) = map_.next_key()? {
15011 match k {
15012 GeneratedField::CreateAt => {
15013 if create_at__.is_some() {
15014 return Err(serde::de::Error::duplicate_field("createAt"));
15015 }
15016 create_at__ =
15017 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15018 ;
15019 }
15020 GeneratedField::Register => {
15021 if event__.is_some() {
15022 return Err(serde::de::Error::duplicate_field("register"));
15023 }
15024 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
15025;
15026 }
15027 GeneratedField::PullTask => {
15028 if event__.is_some() {
15029 return Err(serde::de::Error::duplicate_field("pullTask"));
15030 }
15031 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
15032;
15033 }
15034 GeneratedField::ReportTask => {
15035 if event__.is_some() {
15036 return Err(serde::de::Error::duplicate_field("reportTask"));
15037 }
15038 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
15039;
15040 }
15041 GeneratedField::HeartBeat => {
15042 if event__.is_some() {
15043 return Err(serde::de::Error::duplicate_field("heartBeat"));
15044 }
15045 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
15046;
15047 }
15048 }
15049 }
15050 Ok(SubscribeCompactionEventRequest {
15051 create_at: create_at__.unwrap_or_default(),
15052 event: event__,
15053 })
15054 }
15055 }
15056 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
15057 }
15058}
15059impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
15060 #[allow(deprecated)]
15061 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15062 where
15063 S: serde::Serializer,
15064 {
15065 use serde::ser::SerializeStruct;
15066 let mut len = 0;
15067 if !self.progress.is_empty() {
15068 len += 1;
15069 }
15070 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
15071 if !self.progress.is_empty() {
15072 struct_ser.serialize_field("progress", &self.progress)?;
15073 }
15074 struct_ser.end()
15075 }
15076}
15077impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
15078 #[allow(deprecated)]
15079 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15080 where
15081 D: serde::Deserializer<'de>,
15082 {
15083 const FIELDS: &[&str] = &[
15084 "progress",
15085 ];
15086
15087 #[allow(clippy::enum_variant_names)]
15088 enum GeneratedField {
15089 Progress,
15090 }
15091 impl<'de> serde::Deserialize<'de> for GeneratedField {
15092 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15093 where
15094 D: serde::Deserializer<'de>,
15095 {
15096 struct GeneratedVisitor;
15097
15098 impl serde::de::Visitor<'_> for GeneratedVisitor {
15099 type Value = GeneratedField;
15100
15101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15102 write!(formatter, "expected one of: {:?}", &FIELDS)
15103 }
15104
15105 #[allow(unused_variables)]
15106 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15107 where
15108 E: serde::de::Error,
15109 {
15110 match value {
15111 "progress" => Ok(GeneratedField::Progress),
15112 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15113 }
15114 }
15115 }
15116 deserializer.deserialize_identifier(GeneratedVisitor)
15117 }
15118 }
15119 struct GeneratedVisitor;
15120 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15121 type Value = subscribe_compaction_event_request::HeartBeat;
15122
15123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15124 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
15125 }
15126
15127 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
15128 where
15129 V: serde::de::MapAccess<'de>,
15130 {
15131 let mut progress__ = None;
15132 while let Some(k) = map_.next_key()? {
15133 match k {
15134 GeneratedField::Progress => {
15135 if progress__.is_some() {
15136 return Err(serde::de::Error::duplicate_field("progress"));
15137 }
15138 progress__ = Some(map_.next_value()?);
15139 }
15140 }
15141 }
15142 Ok(subscribe_compaction_event_request::HeartBeat {
15143 progress: progress__.unwrap_or_default(),
15144 })
15145 }
15146 }
15147 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
15148 }
15149}
15150impl serde::Serialize for subscribe_compaction_event_request::PullTask {
15151 #[allow(deprecated)]
15152 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15153 where
15154 S: serde::Serializer,
15155 {
15156 use serde::ser::SerializeStruct;
15157 let mut len = 0;
15158 if self.pull_task_count != 0 {
15159 len += 1;
15160 }
15161 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
15162 if self.pull_task_count != 0 {
15163 struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
15164 }
15165 struct_ser.end()
15166 }
15167}
15168impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
15169 #[allow(deprecated)]
15170 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15171 where
15172 D: serde::Deserializer<'de>,
15173 {
15174 const FIELDS: &[&str] = &[
15175 "pull_task_count",
15176 "pullTaskCount",
15177 ];
15178
15179 #[allow(clippy::enum_variant_names)]
15180 enum GeneratedField {
15181 PullTaskCount,
15182 }
15183 impl<'de> serde::Deserialize<'de> for GeneratedField {
15184 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15185 where
15186 D: serde::Deserializer<'de>,
15187 {
15188 struct GeneratedVisitor;
15189
15190 impl serde::de::Visitor<'_> for GeneratedVisitor {
15191 type Value = GeneratedField;
15192
15193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15194 write!(formatter, "expected one of: {:?}", &FIELDS)
15195 }
15196
15197 #[allow(unused_variables)]
15198 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15199 where
15200 E: serde::de::Error,
15201 {
15202 match value {
15203 "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
15204 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15205 }
15206 }
15207 }
15208 deserializer.deserialize_identifier(GeneratedVisitor)
15209 }
15210 }
15211 struct GeneratedVisitor;
15212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15213 type Value = subscribe_compaction_event_request::PullTask;
15214
15215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15216 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
15217 }
15218
15219 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
15220 where
15221 V: serde::de::MapAccess<'de>,
15222 {
15223 let mut pull_task_count__ = None;
15224 while let Some(k) = map_.next_key()? {
15225 match k {
15226 GeneratedField::PullTaskCount => {
15227 if pull_task_count__.is_some() {
15228 return Err(serde::de::Error::duplicate_field("pullTaskCount"));
15229 }
15230 pull_task_count__ =
15231 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15232 ;
15233 }
15234 }
15235 }
15236 Ok(subscribe_compaction_event_request::PullTask {
15237 pull_task_count: pull_task_count__.unwrap_or_default(),
15238 })
15239 }
15240 }
15241 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
15242 }
15243}
15244impl serde::Serialize for subscribe_compaction_event_request::Register {
15245 #[allow(deprecated)]
15246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15247 where
15248 S: serde::Serializer,
15249 {
15250 use serde::ser::SerializeStruct;
15251 let mut len = 0;
15252 if self.context_id != 0 {
15253 len += 1;
15254 }
15255 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
15256 if self.context_id != 0 {
15257 struct_ser.serialize_field("contextId", &self.context_id)?;
15258 }
15259 struct_ser.end()
15260 }
15261}
15262impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
15263 #[allow(deprecated)]
15264 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15265 where
15266 D: serde::Deserializer<'de>,
15267 {
15268 const FIELDS: &[&str] = &[
15269 "context_id",
15270 "contextId",
15271 ];
15272
15273 #[allow(clippy::enum_variant_names)]
15274 enum GeneratedField {
15275 ContextId,
15276 }
15277 impl<'de> serde::Deserialize<'de> for GeneratedField {
15278 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15279 where
15280 D: serde::Deserializer<'de>,
15281 {
15282 struct GeneratedVisitor;
15283
15284 impl serde::de::Visitor<'_> for GeneratedVisitor {
15285 type Value = GeneratedField;
15286
15287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15288 write!(formatter, "expected one of: {:?}", &FIELDS)
15289 }
15290
15291 #[allow(unused_variables)]
15292 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15293 where
15294 E: serde::de::Error,
15295 {
15296 match value {
15297 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15299 }
15300 }
15301 }
15302 deserializer.deserialize_identifier(GeneratedVisitor)
15303 }
15304 }
15305 struct GeneratedVisitor;
15306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15307 type Value = subscribe_compaction_event_request::Register;
15308
15309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15310 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
15311 }
15312
15313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
15314 where
15315 V: serde::de::MapAccess<'de>,
15316 {
15317 let mut context_id__ = None;
15318 while let Some(k) = map_.next_key()? {
15319 match k {
15320 GeneratedField::ContextId => {
15321 if context_id__.is_some() {
15322 return Err(serde::de::Error::duplicate_field("contextId"));
15323 }
15324 context_id__ =
15325 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15326 ;
15327 }
15328 }
15329 }
15330 Ok(subscribe_compaction_event_request::Register {
15331 context_id: context_id__.unwrap_or_default(),
15332 })
15333 }
15334 }
15335 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
15336 }
15337}
15338impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
15339 #[allow(deprecated)]
15340 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15341 where
15342 S: serde::Serializer,
15343 {
15344 use serde::ser::SerializeStruct;
15345 let mut len = 0;
15346 if !self.table_stats_change.is_empty() {
15347 len += 1;
15348 }
15349 if self.task_id != 0 {
15350 len += 1;
15351 }
15352 if self.task_status != 0 {
15353 len += 1;
15354 }
15355 if !self.sorted_output_ssts.is_empty() {
15356 len += 1;
15357 }
15358 if !self.object_timestamps.is_empty() {
15359 len += 1;
15360 }
15361 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
15362 if !self.table_stats_change.is_empty() {
15363 struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
15364 }
15365 if self.task_id != 0 {
15366 #[allow(clippy::needless_borrow)]
15367 #[allow(clippy::needless_borrows_for_generic_args)]
15368 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
15369 }
15370 if self.task_status != 0 {
15371 let v = compact_task::TaskStatus::try_from(self.task_status)
15372 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
15373 struct_ser.serialize_field("taskStatus", &v)?;
15374 }
15375 if !self.sorted_output_ssts.is_empty() {
15376 struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
15377 }
15378 if !self.object_timestamps.is_empty() {
15379 let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
15380 .map(|(k, v)| (k, v.to_string())).collect();
15381 struct_ser.serialize_field("objectTimestamps", &v)?;
15382 }
15383 struct_ser.end()
15384 }
15385}
15386impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
15387 #[allow(deprecated)]
15388 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15389 where
15390 D: serde::Deserializer<'de>,
15391 {
15392 const FIELDS: &[&str] = &[
15393 "table_stats_change",
15394 "tableStatsChange",
15395 "task_id",
15396 "taskId",
15397 "task_status",
15398 "taskStatus",
15399 "sorted_output_ssts",
15400 "sortedOutputSsts",
15401 "object_timestamps",
15402 "objectTimestamps",
15403 ];
15404
15405 #[allow(clippy::enum_variant_names)]
15406 enum GeneratedField {
15407 TableStatsChange,
15408 TaskId,
15409 TaskStatus,
15410 SortedOutputSsts,
15411 ObjectTimestamps,
15412 }
15413 impl<'de> serde::Deserialize<'de> for GeneratedField {
15414 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15415 where
15416 D: serde::Deserializer<'de>,
15417 {
15418 struct GeneratedVisitor;
15419
15420 impl serde::de::Visitor<'_> for GeneratedVisitor {
15421 type Value = GeneratedField;
15422
15423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15424 write!(formatter, "expected one of: {:?}", &FIELDS)
15425 }
15426
15427 #[allow(unused_variables)]
15428 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15429 where
15430 E: serde::de::Error,
15431 {
15432 match value {
15433 "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
15434 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
15435 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
15436 "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
15437 "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
15438 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15439 }
15440 }
15441 }
15442 deserializer.deserialize_identifier(GeneratedVisitor)
15443 }
15444 }
15445 struct GeneratedVisitor;
15446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15447 type Value = subscribe_compaction_event_request::ReportTask;
15448
15449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15450 formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
15451 }
15452
15453 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
15454 where
15455 V: serde::de::MapAccess<'de>,
15456 {
15457 let mut table_stats_change__ = None;
15458 let mut task_id__ = None;
15459 let mut task_status__ = None;
15460 let mut sorted_output_ssts__ = None;
15461 let mut object_timestamps__ = None;
15462 while let Some(k) = map_.next_key()? {
15463 match k {
15464 GeneratedField::TableStatsChange => {
15465 if table_stats_change__.is_some() {
15466 return Err(serde::de::Error::duplicate_field("tableStatsChange"));
15467 }
15468 table_stats_change__ = Some(
15469 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15470 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15471 );
15472 }
15473 GeneratedField::TaskId => {
15474 if task_id__.is_some() {
15475 return Err(serde::de::Error::duplicate_field("taskId"));
15476 }
15477 task_id__ =
15478 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15479 ;
15480 }
15481 GeneratedField::TaskStatus => {
15482 if task_status__.is_some() {
15483 return Err(serde::de::Error::duplicate_field("taskStatus"));
15484 }
15485 task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
15486 }
15487 GeneratedField::SortedOutputSsts => {
15488 if sorted_output_ssts__.is_some() {
15489 return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
15490 }
15491 sorted_output_ssts__ = Some(map_.next_value()?);
15492 }
15493 GeneratedField::ObjectTimestamps => {
15494 if object_timestamps__.is_some() {
15495 return Err(serde::de::Error::duplicate_field("objectTimestamps"));
15496 }
15497 object_timestamps__ = Some(
15498 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
15499 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
15500 );
15501 }
15502 }
15503 }
15504 Ok(subscribe_compaction_event_request::ReportTask {
15505 table_stats_change: table_stats_change__.unwrap_or_default(),
15506 task_id: task_id__.unwrap_or_default(),
15507 task_status: task_status__.unwrap_or_default(),
15508 sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
15509 object_timestamps: object_timestamps__.unwrap_or_default(),
15510 })
15511 }
15512 }
15513 deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
15514 }
15515}
15516impl serde::Serialize for SubscribeCompactionEventResponse {
15517 #[allow(deprecated)]
15518 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15519 where
15520 S: serde::Serializer,
15521 {
15522 use serde::ser::SerializeStruct;
15523 let mut len = 0;
15524 if self.create_at != 0 {
15525 len += 1;
15526 }
15527 if self.event.is_some() {
15528 len += 1;
15529 }
15530 let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
15531 if self.create_at != 0 {
15532 #[allow(clippy::needless_borrow)]
15533 #[allow(clippy::needless_borrows_for_generic_args)]
15534 struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
15535 }
15536 if let Some(v) = self.event.as_ref() {
15537 match v {
15538 subscribe_compaction_event_response::Event::CompactTask(v) => {
15539 struct_ser.serialize_field("compactTask", v)?;
15540 }
15541 subscribe_compaction_event_response::Event::VacuumTask(v) => {
15542 struct_ser.serialize_field("vacuumTask", v)?;
15543 }
15544 subscribe_compaction_event_response::Event::FullScanTask(v) => {
15545 struct_ser.serialize_field("fullScanTask", v)?;
15546 }
15547 subscribe_compaction_event_response::Event::ValidationTask(v) => {
15548 struct_ser.serialize_field("validationTask", v)?;
15549 }
15550 subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
15551 struct_ser.serialize_field("cancelCompactTask", v)?;
15552 }
15553 subscribe_compaction_event_response::Event::PullTaskAck(v) => {
15554 struct_ser.serialize_field("pullTaskAck", v)?;
15555 }
15556 }
15557 }
15558 struct_ser.end()
15559 }
15560}
15561impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
15562 #[allow(deprecated)]
15563 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15564 where
15565 D: serde::Deserializer<'de>,
15566 {
15567 const FIELDS: &[&str] = &[
15568 "create_at",
15569 "createAt",
15570 "compact_task",
15571 "compactTask",
15572 "vacuum_task",
15573 "vacuumTask",
15574 "full_scan_task",
15575 "fullScanTask",
15576 "validation_task",
15577 "validationTask",
15578 "cancel_compact_task",
15579 "cancelCompactTask",
15580 "pull_task_ack",
15581 "pullTaskAck",
15582 ];
15583
15584 #[allow(clippy::enum_variant_names)]
15585 enum GeneratedField {
15586 CreateAt,
15587 CompactTask,
15588 VacuumTask,
15589 FullScanTask,
15590 ValidationTask,
15591 CancelCompactTask,
15592 PullTaskAck,
15593 }
15594 impl<'de> serde::Deserialize<'de> for GeneratedField {
15595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15596 where
15597 D: serde::Deserializer<'de>,
15598 {
15599 struct GeneratedVisitor;
15600
15601 impl serde::de::Visitor<'_> for GeneratedVisitor {
15602 type Value = GeneratedField;
15603
15604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15605 write!(formatter, "expected one of: {:?}", &FIELDS)
15606 }
15607
15608 #[allow(unused_variables)]
15609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15610 where
15611 E: serde::de::Error,
15612 {
15613 match value {
15614 "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
15615 "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
15616 "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
15617 "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
15618 "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
15619 "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
15620 "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
15621 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15622 }
15623 }
15624 }
15625 deserializer.deserialize_identifier(GeneratedVisitor)
15626 }
15627 }
15628 struct GeneratedVisitor;
15629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15630 type Value = SubscribeCompactionEventResponse;
15631
15632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15633 formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
15634 }
15635
15636 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
15637 where
15638 V: serde::de::MapAccess<'de>,
15639 {
15640 let mut create_at__ = None;
15641 let mut event__ = None;
15642 while let Some(k) = map_.next_key()? {
15643 match k {
15644 GeneratedField::CreateAt => {
15645 if create_at__.is_some() {
15646 return Err(serde::de::Error::duplicate_field("createAt"));
15647 }
15648 create_at__ =
15649 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15650 ;
15651 }
15652 GeneratedField::CompactTask => {
15653 if event__.is_some() {
15654 return Err(serde::de::Error::duplicate_field("compactTask"));
15655 }
15656 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
15657;
15658 }
15659 GeneratedField::VacuumTask => {
15660 if event__.is_some() {
15661 return Err(serde::de::Error::duplicate_field("vacuumTask"));
15662 }
15663 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
15664;
15665 }
15666 GeneratedField::FullScanTask => {
15667 if event__.is_some() {
15668 return Err(serde::de::Error::duplicate_field("fullScanTask"));
15669 }
15670 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
15671;
15672 }
15673 GeneratedField::ValidationTask => {
15674 if event__.is_some() {
15675 return Err(serde::de::Error::duplicate_field("validationTask"));
15676 }
15677 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
15678;
15679 }
15680 GeneratedField::CancelCompactTask => {
15681 if event__.is_some() {
15682 return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
15683 }
15684 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
15685;
15686 }
15687 GeneratedField::PullTaskAck => {
15688 if event__.is_some() {
15689 return Err(serde::de::Error::duplicate_field("pullTaskAck"));
15690 }
15691 event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
15692;
15693 }
15694 }
15695 }
15696 Ok(SubscribeCompactionEventResponse {
15697 create_at: create_at__.unwrap_or_default(),
15698 event: event__,
15699 })
15700 }
15701 }
15702 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
15703 }
15704}
15705impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
15706 #[allow(deprecated)]
15707 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15708 where
15709 S: serde::Serializer,
15710 {
15711 use serde::ser::SerializeStruct;
15712 let len = 0;
15713 let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
15714 struct_ser.end()
15715 }
15716}
15717impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
15718 #[allow(deprecated)]
15719 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15720 where
15721 D: serde::Deserializer<'de>,
15722 {
15723 const FIELDS: &[&str] = &[
15724 ];
15725
15726 #[allow(clippy::enum_variant_names)]
15727 enum GeneratedField {
15728 }
15729 impl<'de> serde::Deserialize<'de> for GeneratedField {
15730 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15731 where
15732 D: serde::Deserializer<'de>,
15733 {
15734 struct GeneratedVisitor;
15735
15736 impl serde::de::Visitor<'_> for GeneratedVisitor {
15737 type Value = GeneratedField;
15738
15739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15740 write!(formatter, "expected one of: {:?}", &FIELDS)
15741 }
15742
15743 #[allow(unused_variables)]
15744 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15745 where
15746 E: serde::de::Error,
15747 {
15748 Err(serde::de::Error::unknown_field(value, FIELDS))
15749 }
15750 }
15751 deserializer.deserialize_identifier(GeneratedVisitor)
15752 }
15753 }
15754 struct GeneratedVisitor;
15755 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15756 type Value = subscribe_compaction_event_response::PullTaskAck;
15757
15758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15759 formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
15760 }
15761
15762 fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
15763 where
15764 V: serde::de::MapAccess<'de>,
15765 {
15766 while map_.next_key::<GeneratedField>()?.is_some() {
15767 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15768 }
15769 Ok(subscribe_compaction_event_response::PullTaskAck {
15770 })
15771 }
15772 }
15773 deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
15774 }
15775}
15776impl serde::Serialize for TableChangeLog {
15777 #[allow(deprecated)]
15778 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15779 where
15780 S: serde::Serializer,
15781 {
15782 use serde::ser::SerializeStruct;
15783 let mut len = 0;
15784 if !self.change_logs.is_empty() {
15785 len += 1;
15786 }
15787 let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
15788 if !self.change_logs.is_empty() {
15789 struct_ser.serialize_field("changeLogs", &self.change_logs)?;
15790 }
15791 struct_ser.end()
15792 }
15793}
15794impl<'de> serde::Deserialize<'de> for TableChangeLog {
15795 #[allow(deprecated)]
15796 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15797 where
15798 D: serde::Deserializer<'de>,
15799 {
15800 const FIELDS: &[&str] = &[
15801 "change_logs",
15802 "changeLogs",
15803 ];
15804
15805 #[allow(clippy::enum_variant_names)]
15806 enum GeneratedField {
15807 ChangeLogs,
15808 }
15809 impl<'de> serde::Deserialize<'de> for GeneratedField {
15810 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15811 where
15812 D: serde::Deserializer<'de>,
15813 {
15814 struct GeneratedVisitor;
15815
15816 impl serde::de::Visitor<'_> for GeneratedVisitor {
15817 type Value = GeneratedField;
15818
15819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15820 write!(formatter, "expected one of: {:?}", &FIELDS)
15821 }
15822
15823 #[allow(unused_variables)]
15824 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15825 where
15826 E: serde::de::Error,
15827 {
15828 match value {
15829 "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
15830 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15831 }
15832 }
15833 }
15834 deserializer.deserialize_identifier(GeneratedVisitor)
15835 }
15836 }
15837 struct GeneratedVisitor;
15838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15839 type Value = TableChangeLog;
15840
15841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15842 formatter.write_str("struct hummock.TableChangeLog")
15843 }
15844
15845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
15846 where
15847 V: serde::de::MapAccess<'de>,
15848 {
15849 let mut change_logs__ = None;
15850 while let Some(k) = map_.next_key()? {
15851 match k {
15852 GeneratedField::ChangeLogs => {
15853 if change_logs__.is_some() {
15854 return Err(serde::de::Error::duplicate_field("changeLogs"));
15855 }
15856 change_logs__ = Some(map_.next_value()?);
15857 }
15858 }
15859 }
15860 Ok(TableChangeLog {
15861 change_logs: change_logs__.unwrap_or_default(),
15862 })
15863 }
15864 }
15865 deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
15866 }
15867}
15868impl serde::Serialize for TableOption {
15869 #[allow(deprecated)]
15870 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15871 where
15872 S: serde::Serializer,
15873 {
15874 use serde::ser::SerializeStruct;
15875 let mut len = 0;
15876 if self.retention_seconds.is_some() {
15877 len += 1;
15878 }
15879 let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
15880 if let Some(v) = self.retention_seconds.as_ref() {
15881 struct_ser.serialize_field("retentionSeconds", v)?;
15882 }
15883 struct_ser.end()
15884 }
15885}
15886impl<'de> serde::Deserialize<'de> for TableOption {
15887 #[allow(deprecated)]
15888 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15889 where
15890 D: serde::Deserializer<'de>,
15891 {
15892 const FIELDS: &[&str] = &[
15893 "retention_seconds",
15894 "retentionSeconds",
15895 ];
15896
15897 #[allow(clippy::enum_variant_names)]
15898 enum GeneratedField {
15899 RetentionSeconds,
15900 }
15901 impl<'de> serde::Deserialize<'de> for GeneratedField {
15902 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15903 where
15904 D: serde::Deserializer<'de>,
15905 {
15906 struct GeneratedVisitor;
15907
15908 impl serde::de::Visitor<'_> for GeneratedVisitor {
15909 type Value = GeneratedField;
15910
15911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15912 write!(formatter, "expected one of: {:?}", &FIELDS)
15913 }
15914
15915 #[allow(unused_variables)]
15916 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15917 where
15918 E: serde::de::Error,
15919 {
15920 match value {
15921 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
15922 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15923 }
15924 }
15925 }
15926 deserializer.deserialize_identifier(GeneratedVisitor)
15927 }
15928 }
15929 struct GeneratedVisitor;
15930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15931 type Value = TableOption;
15932
15933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15934 formatter.write_str("struct hummock.TableOption")
15935 }
15936
15937 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
15938 where
15939 V: serde::de::MapAccess<'de>,
15940 {
15941 let mut retention_seconds__ = None;
15942 while let Some(k) = map_.next_key()? {
15943 match k {
15944 GeneratedField::RetentionSeconds => {
15945 if retention_seconds__.is_some() {
15946 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
15947 }
15948 retention_seconds__ =
15949 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15950 ;
15951 }
15952 }
15953 }
15954 Ok(TableOption {
15955 retention_seconds: retention_seconds__,
15956 })
15957 }
15958 }
15959 deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
15960 }
15961}
15962impl serde::Serialize for TableSchema {
15963 #[allow(deprecated)]
15964 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15965 where
15966 S: serde::Serializer,
15967 {
15968 use serde::ser::SerializeStruct;
15969 let mut len = 0;
15970 if !self.column_ids.is_empty() {
15971 len += 1;
15972 }
15973 let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
15974 if !self.column_ids.is_empty() {
15975 struct_ser.serialize_field("columnIds", &self.column_ids)?;
15976 }
15977 struct_ser.end()
15978 }
15979}
15980impl<'de> serde::Deserialize<'de> for TableSchema {
15981 #[allow(deprecated)]
15982 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15983 where
15984 D: serde::Deserializer<'de>,
15985 {
15986 const FIELDS: &[&str] = &[
15987 "column_ids",
15988 "columnIds",
15989 ];
15990
15991 #[allow(clippy::enum_variant_names)]
15992 enum GeneratedField {
15993 ColumnIds,
15994 }
15995 impl<'de> serde::Deserialize<'de> for GeneratedField {
15996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15997 where
15998 D: serde::Deserializer<'de>,
15999 {
16000 struct GeneratedVisitor;
16001
16002 impl serde::de::Visitor<'_> for GeneratedVisitor {
16003 type Value = GeneratedField;
16004
16005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16006 write!(formatter, "expected one of: {:?}", &FIELDS)
16007 }
16008
16009 #[allow(unused_variables)]
16010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16011 where
16012 E: serde::de::Error,
16013 {
16014 match value {
16015 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
16016 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16017 }
16018 }
16019 }
16020 deserializer.deserialize_identifier(GeneratedVisitor)
16021 }
16022 }
16023 struct GeneratedVisitor;
16024 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16025 type Value = TableSchema;
16026
16027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16028 formatter.write_str("struct hummock.TableSchema")
16029 }
16030
16031 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
16032 where
16033 V: serde::de::MapAccess<'de>,
16034 {
16035 let mut column_ids__ = None;
16036 while let Some(k) = map_.next_key()? {
16037 match k {
16038 GeneratedField::ColumnIds => {
16039 if column_ids__.is_some() {
16040 return Err(serde::de::Error::duplicate_field("columnIds"));
16041 }
16042 column_ids__ =
16043 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16044 .into_iter().map(|x| x.0).collect())
16045 ;
16046 }
16047 }
16048 }
16049 Ok(TableSchema {
16050 column_ids: column_ids__.unwrap_or_default(),
16051 })
16052 }
16053 }
16054 deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
16055 }
16056}
16057impl serde::Serialize for TableStats {
16058 #[allow(deprecated)]
16059 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16060 where
16061 S: serde::Serializer,
16062 {
16063 use serde::ser::SerializeStruct;
16064 let mut len = 0;
16065 if self.total_key_size != 0 {
16066 len += 1;
16067 }
16068 if self.total_value_size != 0 {
16069 len += 1;
16070 }
16071 if self.total_key_count != 0 {
16072 len += 1;
16073 }
16074 if self.total_compressed_size != 0 {
16075 len += 1;
16076 }
16077 let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
16078 if self.total_key_size != 0 {
16079 #[allow(clippy::needless_borrow)]
16080 #[allow(clippy::needless_borrows_for_generic_args)]
16081 struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
16082 }
16083 if self.total_value_size != 0 {
16084 #[allow(clippy::needless_borrow)]
16085 #[allow(clippy::needless_borrows_for_generic_args)]
16086 struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
16087 }
16088 if self.total_key_count != 0 {
16089 #[allow(clippy::needless_borrow)]
16090 #[allow(clippy::needless_borrows_for_generic_args)]
16091 struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
16092 }
16093 if self.total_compressed_size != 0 {
16094 #[allow(clippy::needless_borrow)]
16095 #[allow(clippy::needless_borrows_for_generic_args)]
16096 struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
16097 }
16098 struct_ser.end()
16099 }
16100}
16101impl<'de> serde::Deserialize<'de> for TableStats {
16102 #[allow(deprecated)]
16103 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16104 where
16105 D: serde::Deserializer<'de>,
16106 {
16107 const FIELDS: &[&str] = &[
16108 "total_key_size",
16109 "totalKeySize",
16110 "total_value_size",
16111 "totalValueSize",
16112 "total_key_count",
16113 "totalKeyCount",
16114 "total_compressed_size",
16115 "totalCompressedSize",
16116 ];
16117
16118 #[allow(clippy::enum_variant_names)]
16119 enum GeneratedField {
16120 TotalKeySize,
16121 TotalValueSize,
16122 TotalKeyCount,
16123 TotalCompressedSize,
16124 }
16125 impl<'de> serde::Deserialize<'de> for GeneratedField {
16126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16127 where
16128 D: serde::Deserializer<'de>,
16129 {
16130 struct GeneratedVisitor;
16131
16132 impl serde::de::Visitor<'_> for GeneratedVisitor {
16133 type Value = GeneratedField;
16134
16135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16136 write!(formatter, "expected one of: {:?}", &FIELDS)
16137 }
16138
16139 #[allow(unused_variables)]
16140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16141 where
16142 E: serde::de::Error,
16143 {
16144 match value {
16145 "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
16146 "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
16147 "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
16148 "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
16149 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16150 }
16151 }
16152 }
16153 deserializer.deserialize_identifier(GeneratedVisitor)
16154 }
16155 }
16156 struct GeneratedVisitor;
16157 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16158 type Value = TableStats;
16159
16160 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16161 formatter.write_str("struct hummock.TableStats")
16162 }
16163
16164 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
16165 where
16166 V: serde::de::MapAccess<'de>,
16167 {
16168 let mut total_key_size__ = None;
16169 let mut total_value_size__ = None;
16170 let mut total_key_count__ = None;
16171 let mut total_compressed_size__ = None;
16172 while let Some(k) = map_.next_key()? {
16173 match k {
16174 GeneratedField::TotalKeySize => {
16175 if total_key_size__.is_some() {
16176 return Err(serde::de::Error::duplicate_field("totalKeySize"));
16177 }
16178 total_key_size__ =
16179 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16180 ;
16181 }
16182 GeneratedField::TotalValueSize => {
16183 if total_value_size__.is_some() {
16184 return Err(serde::de::Error::duplicate_field("totalValueSize"));
16185 }
16186 total_value_size__ =
16187 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16188 ;
16189 }
16190 GeneratedField::TotalKeyCount => {
16191 if total_key_count__.is_some() {
16192 return Err(serde::de::Error::duplicate_field("totalKeyCount"));
16193 }
16194 total_key_count__ =
16195 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16196 ;
16197 }
16198 GeneratedField::TotalCompressedSize => {
16199 if total_compressed_size__.is_some() {
16200 return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
16201 }
16202 total_compressed_size__ =
16203 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16204 ;
16205 }
16206 }
16207 }
16208 Ok(TableStats {
16209 total_key_size: total_key_size__.unwrap_or_default(),
16210 total_value_size: total_value_size__.unwrap_or_default(),
16211 total_key_count: total_key_count__.unwrap_or_default(),
16212 total_compressed_size: total_compressed_size__.unwrap_or_default(),
16213 })
16214 }
16215 }
16216 deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
16217 }
16218}
16219impl serde::Serialize for TableWatermarks {
16220 #[allow(deprecated)]
16221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16222 where
16223 S: serde::Serializer,
16224 {
16225 use serde::ser::SerializeStruct;
16226 let mut len = 0;
16227 if !self.epoch_watermarks.is_empty() {
16228 len += 1;
16229 }
16230 if self.is_ascending {
16231 len += 1;
16232 }
16233 if self.is_non_pk_prefix {
16234 len += 1;
16235 }
16236 if self.raw_watermark_serde_type != 0 {
16237 len += 1;
16238 }
16239 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
16240 if !self.epoch_watermarks.is_empty() {
16241 struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
16242 }
16243 if self.is_ascending {
16244 struct_ser.serialize_field("isAscending", &self.is_ascending)?;
16245 }
16246 if self.is_non_pk_prefix {
16247 struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
16248 }
16249 if self.raw_watermark_serde_type != 0 {
16250 let v = WatermarkSerdeType::try_from(self.raw_watermark_serde_type)
16251 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.raw_watermark_serde_type)))?;
16252 struct_ser.serialize_field("rawWatermarkSerdeType", &v)?;
16253 }
16254 struct_ser.end()
16255 }
16256}
16257impl<'de> serde::Deserialize<'de> for TableWatermarks {
16258 #[allow(deprecated)]
16259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16260 where
16261 D: serde::Deserializer<'de>,
16262 {
16263 const FIELDS: &[&str] = &[
16264 "epoch_watermarks",
16265 "epochWatermarks",
16266 "is_ascending",
16267 "isAscending",
16268 "is_non_pk_prefix",
16269 "isNonPkPrefix",
16270 "raw_watermark_serde_type",
16271 "rawWatermarkSerdeType",
16272 ];
16273
16274 #[allow(clippy::enum_variant_names)]
16275 enum GeneratedField {
16276 EpochWatermarks,
16277 IsAscending,
16278 IsNonPkPrefix,
16279 RawWatermarkSerdeType,
16280 }
16281 impl<'de> serde::Deserialize<'de> for GeneratedField {
16282 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16283 where
16284 D: serde::Deserializer<'de>,
16285 {
16286 struct GeneratedVisitor;
16287
16288 impl serde::de::Visitor<'_> for GeneratedVisitor {
16289 type Value = GeneratedField;
16290
16291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16292 write!(formatter, "expected one of: {:?}", &FIELDS)
16293 }
16294
16295 #[allow(unused_variables)]
16296 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16297 where
16298 E: serde::de::Error,
16299 {
16300 match value {
16301 "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
16302 "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
16303 "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
16304 "rawWatermarkSerdeType" | "raw_watermark_serde_type" => Ok(GeneratedField::RawWatermarkSerdeType),
16305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16306 }
16307 }
16308 }
16309 deserializer.deserialize_identifier(GeneratedVisitor)
16310 }
16311 }
16312 struct GeneratedVisitor;
16313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16314 type Value = TableWatermarks;
16315
16316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16317 formatter.write_str("struct hummock.TableWatermarks")
16318 }
16319
16320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
16321 where
16322 V: serde::de::MapAccess<'de>,
16323 {
16324 let mut epoch_watermarks__ = None;
16325 let mut is_ascending__ = None;
16326 let mut is_non_pk_prefix__ = None;
16327 let mut raw_watermark_serde_type__ = None;
16328 while let Some(k) = map_.next_key()? {
16329 match k {
16330 GeneratedField::EpochWatermarks => {
16331 if epoch_watermarks__.is_some() {
16332 return Err(serde::de::Error::duplicate_field("epochWatermarks"));
16333 }
16334 epoch_watermarks__ = Some(map_.next_value()?);
16335 }
16336 GeneratedField::IsAscending => {
16337 if is_ascending__.is_some() {
16338 return Err(serde::de::Error::duplicate_field("isAscending"));
16339 }
16340 is_ascending__ = Some(map_.next_value()?);
16341 }
16342 GeneratedField::IsNonPkPrefix => {
16343 if is_non_pk_prefix__.is_some() {
16344 return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
16345 }
16346 is_non_pk_prefix__ = Some(map_.next_value()?);
16347 }
16348 GeneratedField::RawWatermarkSerdeType => {
16349 if raw_watermark_serde_type__.is_some() {
16350 return Err(serde::de::Error::duplicate_field("rawWatermarkSerdeType"));
16351 }
16352 raw_watermark_serde_type__ = Some(map_.next_value::<WatermarkSerdeType>()? as i32);
16353 }
16354 }
16355 }
16356 Ok(TableWatermarks {
16357 epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
16358 is_ascending: is_ascending__.unwrap_or_default(),
16359 is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
16360 raw_watermark_serde_type: raw_watermark_serde_type__.unwrap_or_default(),
16361 })
16362 }
16363 }
16364 deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
16365 }
16366}
16367impl serde::Serialize for table_watermarks::EpochNewWatermarks {
16368 #[allow(deprecated)]
16369 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16370 where
16371 S: serde::Serializer,
16372 {
16373 use serde::ser::SerializeStruct;
16374 let mut len = 0;
16375 if !self.watermarks.is_empty() {
16376 len += 1;
16377 }
16378 if self.epoch != 0 {
16379 len += 1;
16380 }
16381 let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
16382 if !self.watermarks.is_empty() {
16383 struct_ser.serialize_field("watermarks", &self.watermarks)?;
16384 }
16385 if self.epoch != 0 {
16386 #[allow(clippy::needless_borrow)]
16387 #[allow(clippy::needless_borrows_for_generic_args)]
16388 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
16389 }
16390 struct_ser.end()
16391 }
16392}
16393impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
16394 #[allow(deprecated)]
16395 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16396 where
16397 D: serde::Deserializer<'de>,
16398 {
16399 const FIELDS: &[&str] = &[
16400 "watermarks",
16401 "epoch",
16402 ];
16403
16404 #[allow(clippy::enum_variant_names)]
16405 enum GeneratedField {
16406 Watermarks,
16407 Epoch,
16408 }
16409 impl<'de> serde::Deserialize<'de> for GeneratedField {
16410 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16411 where
16412 D: serde::Deserializer<'de>,
16413 {
16414 struct GeneratedVisitor;
16415
16416 impl serde::de::Visitor<'_> for GeneratedVisitor {
16417 type Value = GeneratedField;
16418
16419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16420 write!(formatter, "expected one of: {:?}", &FIELDS)
16421 }
16422
16423 #[allow(unused_variables)]
16424 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16425 where
16426 E: serde::de::Error,
16427 {
16428 match value {
16429 "watermarks" => Ok(GeneratedField::Watermarks),
16430 "epoch" => Ok(GeneratedField::Epoch),
16431 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16432 }
16433 }
16434 }
16435 deserializer.deserialize_identifier(GeneratedVisitor)
16436 }
16437 }
16438 struct GeneratedVisitor;
16439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16440 type Value = table_watermarks::EpochNewWatermarks;
16441
16442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16443 formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
16444 }
16445
16446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
16447 where
16448 V: serde::de::MapAccess<'de>,
16449 {
16450 let mut watermarks__ = None;
16451 let mut epoch__ = None;
16452 while let Some(k) = map_.next_key()? {
16453 match k {
16454 GeneratedField::Watermarks => {
16455 if watermarks__.is_some() {
16456 return Err(serde::de::Error::duplicate_field("watermarks"));
16457 }
16458 watermarks__ = Some(map_.next_value()?);
16459 }
16460 GeneratedField::Epoch => {
16461 if epoch__.is_some() {
16462 return Err(serde::de::Error::duplicate_field("epoch"));
16463 }
16464 epoch__ =
16465 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16466 ;
16467 }
16468 }
16469 }
16470 Ok(table_watermarks::EpochNewWatermarks {
16471 watermarks: watermarks__.unwrap_or_default(),
16472 epoch: epoch__.unwrap_or_default(),
16473 })
16474 }
16475 }
16476 deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
16477 }
16478}
16479impl serde::Serialize for TriggerCompactionDeterministicRequest {
16480 #[allow(deprecated)]
16481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16482 where
16483 S: serde::Serializer,
16484 {
16485 use serde::ser::SerializeStruct;
16486 let mut len = 0;
16487 if self.version_id != 0 {
16488 len += 1;
16489 }
16490 if !self.compaction_groups.is_empty() {
16491 len += 1;
16492 }
16493 let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
16494 if self.version_id != 0 {
16495 #[allow(clippy::needless_borrow)]
16496 #[allow(clippy::needless_borrows_for_generic_args)]
16497 struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
16498 }
16499 if !self.compaction_groups.is_empty() {
16500 struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16501 }
16502 struct_ser.end()
16503 }
16504}
16505impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
16506 #[allow(deprecated)]
16507 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16508 where
16509 D: serde::Deserializer<'de>,
16510 {
16511 const FIELDS: &[&str] = &[
16512 "version_id",
16513 "versionId",
16514 "compaction_groups",
16515 "compactionGroups",
16516 ];
16517
16518 #[allow(clippy::enum_variant_names)]
16519 enum GeneratedField {
16520 VersionId,
16521 CompactionGroups,
16522 }
16523 impl<'de> serde::Deserialize<'de> for GeneratedField {
16524 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16525 where
16526 D: serde::Deserializer<'de>,
16527 {
16528 struct GeneratedVisitor;
16529
16530 impl serde::de::Visitor<'_> for GeneratedVisitor {
16531 type Value = GeneratedField;
16532
16533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16534 write!(formatter, "expected one of: {:?}", &FIELDS)
16535 }
16536
16537 #[allow(unused_variables)]
16538 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16539 where
16540 E: serde::de::Error,
16541 {
16542 match value {
16543 "versionId" | "version_id" => Ok(GeneratedField::VersionId),
16544 "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
16545 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16546 }
16547 }
16548 }
16549 deserializer.deserialize_identifier(GeneratedVisitor)
16550 }
16551 }
16552 struct GeneratedVisitor;
16553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16554 type Value = TriggerCompactionDeterministicRequest;
16555
16556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16557 formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
16558 }
16559
16560 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
16561 where
16562 V: serde::de::MapAccess<'de>,
16563 {
16564 let mut version_id__ = None;
16565 let mut compaction_groups__ = None;
16566 while let Some(k) = map_.next_key()? {
16567 match k {
16568 GeneratedField::VersionId => {
16569 if version_id__.is_some() {
16570 return Err(serde::de::Error::duplicate_field("versionId"));
16571 }
16572 version_id__ =
16573 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16574 ;
16575 }
16576 GeneratedField::CompactionGroups => {
16577 if compaction_groups__.is_some() {
16578 return Err(serde::de::Error::duplicate_field("compactionGroups"));
16579 }
16580 compaction_groups__ =
16581 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16582 .into_iter().map(|x| x.0).collect())
16583 ;
16584 }
16585 }
16586 }
16587 Ok(TriggerCompactionDeterministicRequest {
16588 version_id: version_id__.unwrap_or_default(),
16589 compaction_groups: compaction_groups__.unwrap_or_default(),
16590 })
16591 }
16592 }
16593 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
16594 }
16595}
16596impl serde::Serialize for TriggerCompactionDeterministicResponse {
16597 #[allow(deprecated)]
16598 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16599 where
16600 S: serde::Serializer,
16601 {
16602 use serde::ser::SerializeStruct;
16603 let len = 0;
16604 let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
16605 struct_ser.end()
16606 }
16607}
16608impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
16609 #[allow(deprecated)]
16610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16611 where
16612 D: serde::Deserializer<'de>,
16613 {
16614 const FIELDS: &[&str] = &[
16615 ];
16616
16617 #[allow(clippy::enum_variant_names)]
16618 enum GeneratedField {
16619 }
16620 impl<'de> serde::Deserialize<'de> for GeneratedField {
16621 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16622 where
16623 D: serde::Deserializer<'de>,
16624 {
16625 struct GeneratedVisitor;
16626
16627 impl serde::de::Visitor<'_> for GeneratedVisitor {
16628 type Value = GeneratedField;
16629
16630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16631 write!(formatter, "expected one of: {:?}", &FIELDS)
16632 }
16633
16634 #[allow(unused_variables)]
16635 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16636 where
16637 E: serde::de::Error,
16638 {
16639 Err(serde::de::Error::unknown_field(value, FIELDS))
16640 }
16641 }
16642 deserializer.deserialize_identifier(GeneratedVisitor)
16643 }
16644 }
16645 struct GeneratedVisitor;
16646 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16647 type Value = TriggerCompactionDeterministicResponse;
16648
16649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16650 formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
16651 }
16652
16653 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
16654 where
16655 V: serde::de::MapAccess<'de>,
16656 {
16657 while map_.next_key::<GeneratedField>()?.is_some() {
16658 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16659 }
16660 Ok(TriggerCompactionDeterministicResponse {
16661 })
16662 }
16663 }
16664 deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
16665 }
16666}
16667impl serde::Serialize for TriggerFullGcRequest {
16668 #[allow(deprecated)]
16669 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16670 where
16671 S: serde::Serializer,
16672 {
16673 use serde::ser::SerializeStruct;
16674 let mut len = 0;
16675 if self.sst_retention_time_sec != 0 {
16676 len += 1;
16677 }
16678 if self.prefix.is_some() {
16679 len += 1;
16680 }
16681 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
16682 if self.sst_retention_time_sec != 0 {
16683 #[allow(clippy::needless_borrow)]
16684 #[allow(clippy::needless_borrows_for_generic_args)]
16685 struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
16686 }
16687 if let Some(v) = self.prefix.as_ref() {
16688 struct_ser.serialize_field("prefix", v)?;
16689 }
16690 struct_ser.end()
16691 }
16692}
16693impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
16694 #[allow(deprecated)]
16695 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16696 where
16697 D: serde::Deserializer<'de>,
16698 {
16699 const FIELDS: &[&str] = &[
16700 "sst_retention_time_sec",
16701 "sstRetentionTimeSec",
16702 "prefix",
16703 ];
16704
16705 #[allow(clippy::enum_variant_names)]
16706 enum GeneratedField {
16707 SstRetentionTimeSec,
16708 Prefix,
16709 }
16710 impl<'de> serde::Deserialize<'de> for GeneratedField {
16711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16712 where
16713 D: serde::Deserializer<'de>,
16714 {
16715 struct GeneratedVisitor;
16716
16717 impl serde::de::Visitor<'_> for GeneratedVisitor {
16718 type Value = GeneratedField;
16719
16720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16721 write!(formatter, "expected one of: {:?}", &FIELDS)
16722 }
16723
16724 #[allow(unused_variables)]
16725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16726 where
16727 E: serde::de::Error,
16728 {
16729 match value {
16730 "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
16731 "prefix" => Ok(GeneratedField::Prefix),
16732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16733 }
16734 }
16735 }
16736 deserializer.deserialize_identifier(GeneratedVisitor)
16737 }
16738 }
16739 struct GeneratedVisitor;
16740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16741 type Value = TriggerFullGcRequest;
16742
16743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16744 formatter.write_str("struct hummock.TriggerFullGCRequest")
16745 }
16746
16747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
16748 where
16749 V: serde::de::MapAccess<'de>,
16750 {
16751 let mut sst_retention_time_sec__ = None;
16752 let mut prefix__ = None;
16753 while let Some(k) = map_.next_key()? {
16754 match k {
16755 GeneratedField::SstRetentionTimeSec => {
16756 if sst_retention_time_sec__.is_some() {
16757 return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
16758 }
16759 sst_retention_time_sec__ =
16760 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16761 ;
16762 }
16763 GeneratedField::Prefix => {
16764 if prefix__.is_some() {
16765 return Err(serde::de::Error::duplicate_field("prefix"));
16766 }
16767 prefix__ = map_.next_value()?;
16768 }
16769 }
16770 }
16771 Ok(TriggerFullGcRequest {
16772 sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
16773 prefix: prefix__,
16774 })
16775 }
16776 }
16777 deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
16778 }
16779}
16780impl serde::Serialize for TriggerFullGcResponse {
16781 #[allow(deprecated)]
16782 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16783 where
16784 S: serde::Serializer,
16785 {
16786 use serde::ser::SerializeStruct;
16787 let mut len = 0;
16788 if self.status.is_some() {
16789 len += 1;
16790 }
16791 let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
16792 if let Some(v) = self.status.as_ref() {
16793 struct_ser.serialize_field("status", v)?;
16794 }
16795 struct_ser.end()
16796 }
16797}
16798impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
16799 #[allow(deprecated)]
16800 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16801 where
16802 D: serde::Deserializer<'de>,
16803 {
16804 const FIELDS: &[&str] = &[
16805 "status",
16806 ];
16807
16808 #[allow(clippy::enum_variant_names)]
16809 enum GeneratedField {
16810 Status,
16811 }
16812 impl<'de> serde::Deserialize<'de> for GeneratedField {
16813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16814 where
16815 D: serde::Deserializer<'de>,
16816 {
16817 struct GeneratedVisitor;
16818
16819 impl serde::de::Visitor<'_> for GeneratedVisitor {
16820 type Value = GeneratedField;
16821
16822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16823 write!(formatter, "expected one of: {:?}", &FIELDS)
16824 }
16825
16826 #[allow(unused_variables)]
16827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16828 where
16829 E: serde::de::Error,
16830 {
16831 match value {
16832 "status" => Ok(GeneratedField::Status),
16833 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16834 }
16835 }
16836 }
16837 deserializer.deserialize_identifier(GeneratedVisitor)
16838 }
16839 }
16840 struct GeneratedVisitor;
16841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16842 type Value = TriggerFullGcResponse;
16843
16844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16845 formatter.write_str("struct hummock.TriggerFullGCResponse")
16846 }
16847
16848 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
16849 where
16850 V: serde::de::MapAccess<'de>,
16851 {
16852 let mut status__ = None;
16853 while let Some(k) = map_.next_key()? {
16854 match k {
16855 GeneratedField::Status => {
16856 if status__.is_some() {
16857 return Err(serde::de::Error::duplicate_field("status"));
16858 }
16859 status__ = map_.next_value()?;
16860 }
16861 }
16862 }
16863 Ok(TriggerFullGcResponse {
16864 status: status__,
16865 })
16866 }
16867 }
16868 deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
16869 }
16870}
16871impl serde::Serialize for TriggerManualCompactionRequest {
16872 #[allow(deprecated)]
16873 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16874 where
16875 S: serde::Serializer,
16876 {
16877 use serde::ser::SerializeStruct;
16878 let mut len = 0;
16879 if self.compaction_group_id != 0 {
16880 len += 1;
16881 }
16882 if self.key_range.is_some() {
16883 len += 1;
16884 }
16885 if self.table_id != 0 {
16886 len += 1;
16887 }
16888 if self.level != 0 {
16889 len += 1;
16890 }
16891 if !self.sst_ids.is_empty() {
16892 len += 1;
16893 }
16894 if self.exclusive.is_some() {
16895 len += 1;
16896 }
16897 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
16898 if self.compaction_group_id != 0 {
16899 #[allow(clippy::needless_borrow)]
16900 #[allow(clippy::needless_borrows_for_generic_args)]
16901 struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
16902 }
16903 if let Some(v) = self.key_range.as_ref() {
16904 struct_ser.serialize_field("keyRange", v)?;
16905 }
16906 if self.table_id != 0 {
16907 struct_ser.serialize_field("tableId", &self.table_id)?;
16908 }
16909 if self.level != 0 {
16910 struct_ser.serialize_field("level", &self.level)?;
16911 }
16912 if !self.sst_ids.is_empty() {
16913 struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16914 }
16915 if let Some(v) = self.exclusive.as_ref() {
16916 struct_ser.serialize_field("exclusive", v)?;
16917 }
16918 struct_ser.end()
16919 }
16920}
16921impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
16922 #[allow(deprecated)]
16923 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16924 where
16925 D: serde::Deserializer<'de>,
16926 {
16927 const FIELDS: &[&str] = &[
16928 "compaction_group_id",
16929 "compactionGroupId",
16930 "key_range",
16931 "keyRange",
16932 "table_id",
16933 "tableId",
16934 "level",
16935 "sst_ids",
16936 "sstIds",
16937 "exclusive",
16938 ];
16939
16940 #[allow(clippy::enum_variant_names)]
16941 enum GeneratedField {
16942 CompactionGroupId,
16943 KeyRange,
16944 TableId,
16945 Level,
16946 SstIds,
16947 Exclusive,
16948 }
16949 impl<'de> serde::Deserialize<'de> for GeneratedField {
16950 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16951 where
16952 D: serde::Deserializer<'de>,
16953 {
16954 struct GeneratedVisitor;
16955
16956 impl serde::de::Visitor<'_> for GeneratedVisitor {
16957 type Value = GeneratedField;
16958
16959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16960 write!(formatter, "expected one of: {:?}", &FIELDS)
16961 }
16962
16963 #[allow(unused_variables)]
16964 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16965 where
16966 E: serde::de::Error,
16967 {
16968 match value {
16969 "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
16970 "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
16971 "tableId" | "table_id" => Ok(GeneratedField::TableId),
16972 "level" => Ok(GeneratedField::Level),
16973 "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
16974 "exclusive" => Ok(GeneratedField::Exclusive),
16975 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16976 }
16977 }
16978 }
16979 deserializer.deserialize_identifier(GeneratedVisitor)
16980 }
16981 }
16982 struct GeneratedVisitor;
16983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16984 type Value = TriggerManualCompactionRequest;
16985
16986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16987 formatter.write_str("struct hummock.TriggerManualCompactionRequest")
16988 }
16989
16990 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
16991 where
16992 V: serde::de::MapAccess<'de>,
16993 {
16994 let mut compaction_group_id__ = None;
16995 let mut key_range__ = None;
16996 let mut table_id__ = None;
16997 let mut level__ = None;
16998 let mut sst_ids__ = None;
16999 let mut exclusive__ = None;
17000 while let Some(k) = map_.next_key()? {
17001 match k {
17002 GeneratedField::CompactionGroupId => {
17003 if compaction_group_id__.is_some() {
17004 return Err(serde::de::Error::duplicate_field("compactionGroupId"));
17005 }
17006 compaction_group_id__ =
17007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17008 ;
17009 }
17010 GeneratedField::KeyRange => {
17011 if key_range__.is_some() {
17012 return Err(serde::de::Error::duplicate_field("keyRange"));
17013 }
17014 key_range__ = map_.next_value()?;
17015 }
17016 GeneratedField::TableId => {
17017 if table_id__.is_some() {
17018 return Err(serde::de::Error::duplicate_field("tableId"));
17019 }
17020 table_id__ =
17021 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17022 ;
17023 }
17024 GeneratedField::Level => {
17025 if level__.is_some() {
17026 return Err(serde::de::Error::duplicate_field("level"));
17027 }
17028 level__ =
17029 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17030 ;
17031 }
17032 GeneratedField::SstIds => {
17033 if sst_ids__.is_some() {
17034 return Err(serde::de::Error::duplicate_field("sstIds"));
17035 }
17036 sst_ids__ =
17037 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17038 .into_iter().map(|x| x.0).collect())
17039 ;
17040 }
17041 GeneratedField::Exclusive => {
17042 if exclusive__.is_some() {
17043 return Err(serde::de::Error::duplicate_field("exclusive"));
17044 }
17045 exclusive__ = map_.next_value()?;
17046 }
17047 }
17048 }
17049 Ok(TriggerManualCompactionRequest {
17050 compaction_group_id: compaction_group_id__.unwrap_or_default(),
17051 key_range: key_range__,
17052 table_id: table_id__.unwrap_or_default(),
17053 level: level__.unwrap_or_default(),
17054 sst_ids: sst_ids__.unwrap_or_default(),
17055 exclusive: exclusive__,
17056 })
17057 }
17058 }
17059 deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
17060 }
17061}
17062impl serde::Serialize for TriggerManualCompactionResponse {
17063 #[allow(deprecated)]
17064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17065 where
17066 S: serde::Serializer,
17067 {
17068 use serde::ser::SerializeStruct;
17069 let mut len = 0;
17070 if self.status.is_some() {
17071 len += 1;
17072 }
17073 if self.should_retry.is_some() {
17074 len += 1;
17075 }
17076 let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
17077 if let Some(v) = self.status.as_ref() {
17078 struct_ser.serialize_field("status", v)?;
17079 }
17080 if let Some(v) = self.should_retry.as_ref() {
17081 struct_ser.serialize_field("shouldRetry", v)?;
17082 }
17083 struct_ser.end()
17084 }
17085}
17086impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
17087 #[allow(deprecated)]
17088 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17089 where
17090 D: serde::Deserializer<'de>,
17091 {
17092 const FIELDS: &[&str] = &[
17093 "status",
17094 "should_retry",
17095 "shouldRetry",
17096 ];
17097
17098 #[allow(clippy::enum_variant_names)]
17099 enum GeneratedField {
17100 Status,
17101 ShouldRetry,
17102 }
17103 impl<'de> serde::Deserialize<'de> for GeneratedField {
17104 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17105 where
17106 D: serde::Deserializer<'de>,
17107 {
17108 struct GeneratedVisitor;
17109
17110 impl serde::de::Visitor<'_> for GeneratedVisitor {
17111 type Value = GeneratedField;
17112
17113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17114 write!(formatter, "expected one of: {:?}", &FIELDS)
17115 }
17116
17117 #[allow(unused_variables)]
17118 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17119 where
17120 E: serde::de::Error,
17121 {
17122 match value {
17123 "status" => Ok(GeneratedField::Status),
17124 "shouldRetry" | "should_retry" => Ok(GeneratedField::ShouldRetry),
17125 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17126 }
17127 }
17128 }
17129 deserializer.deserialize_identifier(GeneratedVisitor)
17130 }
17131 }
17132 struct GeneratedVisitor;
17133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17134 type Value = TriggerManualCompactionResponse;
17135
17136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17137 formatter.write_str("struct hummock.TriggerManualCompactionResponse")
17138 }
17139
17140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
17141 where
17142 V: serde::de::MapAccess<'de>,
17143 {
17144 let mut status__ = None;
17145 let mut should_retry__ = None;
17146 while let Some(k) = map_.next_key()? {
17147 match k {
17148 GeneratedField::Status => {
17149 if status__.is_some() {
17150 return Err(serde::de::Error::duplicate_field("status"));
17151 }
17152 status__ = map_.next_value()?;
17153 }
17154 GeneratedField::ShouldRetry => {
17155 if should_retry__.is_some() {
17156 return Err(serde::de::Error::duplicate_field("shouldRetry"));
17157 }
17158 should_retry__ = map_.next_value()?;
17159 }
17160 }
17161 }
17162 Ok(TriggerManualCompactionResponse {
17163 status: status__,
17164 should_retry: should_retry__,
17165 })
17166 }
17167 }
17168 deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
17169 }
17170}
17171impl serde::Serialize for TruncateTables {
17172 #[allow(deprecated)]
17173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17174 where
17175 S: serde::Serializer,
17176 {
17177 use serde::ser::SerializeStruct;
17178 let mut len = 0;
17179 if !self.table_ids.is_empty() {
17180 len += 1;
17181 }
17182 let mut struct_ser = serializer.serialize_struct("hummock.TruncateTables", len)?;
17183 if !self.table_ids.is_empty() {
17184 struct_ser.serialize_field("tableIds", &self.table_ids)?;
17185 }
17186 struct_ser.end()
17187 }
17188}
17189impl<'de> serde::Deserialize<'de> for TruncateTables {
17190 #[allow(deprecated)]
17191 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17192 where
17193 D: serde::Deserializer<'de>,
17194 {
17195 const FIELDS: &[&str] = &[
17196 "table_ids",
17197 "tableIds",
17198 ];
17199
17200 #[allow(clippy::enum_variant_names)]
17201 enum GeneratedField {
17202 TableIds,
17203 }
17204 impl<'de> serde::Deserialize<'de> for GeneratedField {
17205 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17206 where
17207 D: serde::Deserializer<'de>,
17208 {
17209 struct GeneratedVisitor;
17210
17211 impl serde::de::Visitor<'_> for GeneratedVisitor {
17212 type Value = GeneratedField;
17213
17214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17215 write!(formatter, "expected one of: {:?}", &FIELDS)
17216 }
17217
17218 #[allow(unused_variables)]
17219 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17220 where
17221 E: serde::de::Error,
17222 {
17223 match value {
17224 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
17225 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17226 }
17227 }
17228 }
17229 deserializer.deserialize_identifier(GeneratedVisitor)
17230 }
17231 }
17232 struct GeneratedVisitor;
17233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17234 type Value = TruncateTables;
17235
17236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17237 formatter.write_str("struct hummock.TruncateTables")
17238 }
17239
17240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TruncateTables, V::Error>
17241 where
17242 V: serde::de::MapAccess<'de>,
17243 {
17244 let mut table_ids__ = None;
17245 while let Some(k) = map_.next_key()? {
17246 match k {
17247 GeneratedField::TableIds => {
17248 if table_ids__.is_some() {
17249 return Err(serde::de::Error::duplicate_field("tableIds"));
17250 }
17251 table_ids__ =
17252 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17253 .into_iter().map(|x| x.0).collect())
17254 ;
17255 }
17256 }
17257 }
17258 Ok(TruncateTables {
17259 table_ids: table_ids__.unwrap_or_default(),
17260 })
17261 }
17262 }
17263 deserializer.deserialize_struct("hummock.TruncateTables", FIELDS, GeneratedVisitor)
17264 }
17265}
17266impl serde::Serialize for UnpinVersionBeforeRequest {
17267 #[allow(deprecated)]
17268 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17269 where
17270 S: serde::Serializer,
17271 {
17272 use serde::ser::SerializeStruct;
17273 let mut len = 0;
17274 if self.context_id != 0 {
17275 len += 1;
17276 }
17277 if self.unpin_version_before != 0 {
17278 len += 1;
17279 }
17280 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
17281 if self.context_id != 0 {
17282 struct_ser.serialize_field("contextId", &self.context_id)?;
17283 }
17284 if self.unpin_version_before != 0 {
17285 #[allow(clippy::needless_borrow)]
17286 #[allow(clippy::needless_borrows_for_generic_args)]
17287 struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
17288 }
17289 struct_ser.end()
17290 }
17291}
17292impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
17293 #[allow(deprecated)]
17294 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17295 where
17296 D: serde::Deserializer<'de>,
17297 {
17298 const FIELDS: &[&str] = &[
17299 "context_id",
17300 "contextId",
17301 "unpin_version_before",
17302 "unpinVersionBefore",
17303 ];
17304
17305 #[allow(clippy::enum_variant_names)]
17306 enum GeneratedField {
17307 ContextId,
17308 UnpinVersionBefore,
17309 }
17310 impl<'de> serde::Deserialize<'de> for GeneratedField {
17311 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17312 where
17313 D: serde::Deserializer<'de>,
17314 {
17315 struct GeneratedVisitor;
17316
17317 impl serde::de::Visitor<'_> for GeneratedVisitor {
17318 type Value = GeneratedField;
17319
17320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17321 write!(formatter, "expected one of: {:?}", &FIELDS)
17322 }
17323
17324 #[allow(unused_variables)]
17325 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17326 where
17327 E: serde::de::Error,
17328 {
17329 match value {
17330 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
17331 "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
17332 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17333 }
17334 }
17335 }
17336 deserializer.deserialize_identifier(GeneratedVisitor)
17337 }
17338 }
17339 struct GeneratedVisitor;
17340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17341 type Value = UnpinVersionBeforeRequest;
17342
17343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17344 formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
17345 }
17346
17347 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
17348 where
17349 V: serde::de::MapAccess<'de>,
17350 {
17351 let mut context_id__ = None;
17352 let mut unpin_version_before__ = None;
17353 while let Some(k) = map_.next_key()? {
17354 match k {
17355 GeneratedField::ContextId => {
17356 if context_id__.is_some() {
17357 return Err(serde::de::Error::duplicate_field("contextId"));
17358 }
17359 context_id__ =
17360 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17361 ;
17362 }
17363 GeneratedField::UnpinVersionBefore => {
17364 if unpin_version_before__.is_some() {
17365 return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
17366 }
17367 unpin_version_before__ =
17368 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17369 ;
17370 }
17371 }
17372 }
17373 Ok(UnpinVersionBeforeRequest {
17374 context_id: context_id__.unwrap_or_default(),
17375 unpin_version_before: unpin_version_before__.unwrap_or_default(),
17376 })
17377 }
17378 }
17379 deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
17380 }
17381}
17382impl serde::Serialize for UnpinVersionBeforeResponse {
17383 #[allow(deprecated)]
17384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17385 where
17386 S: serde::Serializer,
17387 {
17388 use serde::ser::SerializeStruct;
17389 let mut len = 0;
17390 if self.status.is_some() {
17391 len += 1;
17392 }
17393 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
17394 if let Some(v) = self.status.as_ref() {
17395 struct_ser.serialize_field("status", v)?;
17396 }
17397 struct_ser.end()
17398 }
17399}
17400impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
17401 #[allow(deprecated)]
17402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17403 where
17404 D: serde::Deserializer<'de>,
17405 {
17406 const FIELDS: &[&str] = &[
17407 "status",
17408 ];
17409
17410 #[allow(clippy::enum_variant_names)]
17411 enum GeneratedField {
17412 Status,
17413 }
17414 impl<'de> serde::Deserialize<'de> for GeneratedField {
17415 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17416 where
17417 D: serde::Deserializer<'de>,
17418 {
17419 struct GeneratedVisitor;
17420
17421 impl serde::de::Visitor<'_> for GeneratedVisitor {
17422 type Value = GeneratedField;
17423
17424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17425 write!(formatter, "expected one of: {:?}", &FIELDS)
17426 }
17427
17428 #[allow(unused_variables)]
17429 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17430 where
17431 E: serde::de::Error,
17432 {
17433 match value {
17434 "status" => Ok(GeneratedField::Status),
17435 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17436 }
17437 }
17438 }
17439 deserializer.deserialize_identifier(GeneratedVisitor)
17440 }
17441 }
17442 struct GeneratedVisitor;
17443 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17444 type Value = UnpinVersionBeforeResponse;
17445
17446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17447 formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
17448 }
17449
17450 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
17451 where
17452 V: serde::de::MapAccess<'de>,
17453 {
17454 let mut status__ = None;
17455 while let Some(k) = map_.next_key()? {
17456 match k {
17457 GeneratedField::Status => {
17458 if status__.is_some() {
17459 return Err(serde::de::Error::duplicate_field("status"));
17460 }
17461 status__ = map_.next_value()?;
17462 }
17463 }
17464 }
17465 Ok(UnpinVersionBeforeResponse {
17466 status: status__,
17467 })
17468 }
17469 }
17470 deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
17471 }
17472}
17473impl serde::Serialize for UnpinVersionRequest {
17474 #[allow(deprecated)]
17475 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17476 where
17477 S: serde::Serializer,
17478 {
17479 use serde::ser::SerializeStruct;
17480 let mut len = 0;
17481 if self.context_id != 0 {
17482 len += 1;
17483 }
17484 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
17485 if self.context_id != 0 {
17486 struct_ser.serialize_field("contextId", &self.context_id)?;
17487 }
17488 struct_ser.end()
17489 }
17490}
17491impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
17492 #[allow(deprecated)]
17493 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17494 where
17495 D: serde::Deserializer<'de>,
17496 {
17497 const FIELDS: &[&str] = &[
17498 "context_id",
17499 "contextId",
17500 ];
17501
17502 #[allow(clippy::enum_variant_names)]
17503 enum GeneratedField {
17504 ContextId,
17505 }
17506 impl<'de> serde::Deserialize<'de> for GeneratedField {
17507 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17508 where
17509 D: serde::Deserializer<'de>,
17510 {
17511 struct GeneratedVisitor;
17512
17513 impl serde::de::Visitor<'_> for GeneratedVisitor {
17514 type Value = GeneratedField;
17515
17516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17517 write!(formatter, "expected one of: {:?}", &FIELDS)
17518 }
17519
17520 #[allow(unused_variables)]
17521 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17522 where
17523 E: serde::de::Error,
17524 {
17525 match value {
17526 "contextId" | "context_id" => Ok(GeneratedField::ContextId),
17527 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17528 }
17529 }
17530 }
17531 deserializer.deserialize_identifier(GeneratedVisitor)
17532 }
17533 }
17534 struct GeneratedVisitor;
17535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17536 type Value = UnpinVersionRequest;
17537
17538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17539 formatter.write_str("struct hummock.UnpinVersionRequest")
17540 }
17541
17542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
17543 where
17544 V: serde::de::MapAccess<'de>,
17545 {
17546 let mut context_id__ = None;
17547 while let Some(k) = map_.next_key()? {
17548 match k {
17549 GeneratedField::ContextId => {
17550 if context_id__.is_some() {
17551 return Err(serde::de::Error::duplicate_field("contextId"));
17552 }
17553 context_id__ =
17554 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17555 ;
17556 }
17557 }
17558 }
17559 Ok(UnpinVersionRequest {
17560 context_id: context_id__.unwrap_or_default(),
17561 })
17562 }
17563 }
17564 deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
17565 }
17566}
17567impl serde::Serialize for UnpinVersionResponse {
17568 #[allow(deprecated)]
17569 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17570 where
17571 S: serde::Serializer,
17572 {
17573 use serde::ser::SerializeStruct;
17574 let mut len = 0;
17575 if self.status.is_some() {
17576 len += 1;
17577 }
17578 let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
17579 if let Some(v) = self.status.as_ref() {
17580 struct_ser.serialize_field("status", v)?;
17581 }
17582 struct_ser.end()
17583 }
17584}
17585impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
17586 #[allow(deprecated)]
17587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17588 where
17589 D: serde::Deserializer<'de>,
17590 {
17591 const FIELDS: &[&str] = &[
17592 "status",
17593 ];
17594
17595 #[allow(clippy::enum_variant_names)]
17596 enum GeneratedField {
17597 Status,
17598 }
17599 impl<'de> serde::Deserialize<'de> for GeneratedField {
17600 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17601 where
17602 D: serde::Deserializer<'de>,
17603 {
17604 struct GeneratedVisitor;
17605
17606 impl serde::de::Visitor<'_> for GeneratedVisitor {
17607 type Value = GeneratedField;
17608
17609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17610 write!(formatter, "expected one of: {:?}", &FIELDS)
17611 }
17612
17613 #[allow(unused_variables)]
17614 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17615 where
17616 E: serde::de::Error,
17617 {
17618 match value {
17619 "status" => Ok(GeneratedField::Status),
17620 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17621 }
17622 }
17623 }
17624 deserializer.deserialize_identifier(GeneratedVisitor)
17625 }
17626 }
17627 struct GeneratedVisitor;
17628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17629 type Value = UnpinVersionResponse;
17630
17631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17632 formatter.write_str("struct hummock.UnpinVersionResponse")
17633 }
17634
17635 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
17636 where
17637 V: serde::de::MapAccess<'de>,
17638 {
17639 let mut status__ = None;
17640 while let Some(k) = map_.next_key()? {
17641 match k {
17642 GeneratedField::Status => {
17643 if status__.is_some() {
17644 return Err(serde::de::Error::duplicate_field("status"));
17645 }
17646 status__ = map_.next_value()?;
17647 }
17648 }
17649 }
17650 Ok(UnpinVersionResponse {
17651 status: status__,
17652 })
17653 }
17654 }
17655 deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
17656 }
17657}
17658impl serde::Serialize for VacuumTask {
17659 #[allow(deprecated)]
17660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17661 where
17662 S: serde::Serializer,
17663 {
17664 use serde::ser::SerializeStruct;
17665 let mut len = 0;
17666 if !self.sstable_object_ids.is_empty() {
17667 len += 1;
17668 }
17669 let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
17670 if !self.sstable_object_ids.is_empty() {
17671 struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
17672 }
17673 struct_ser.end()
17674 }
17675}
17676impl<'de> serde::Deserialize<'de> for VacuumTask {
17677 #[allow(deprecated)]
17678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17679 where
17680 D: serde::Deserializer<'de>,
17681 {
17682 const FIELDS: &[&str] = &[
17683 "sstable_object_ids",
17684 "sstableObjectIds",
17685 ];
17686
17687 #[allow(clippy::enum_variant_names)]
17688 enum GeneratedField {
17689 SstableObjectIds,
17690 }
17691 impl<'de> serde::Deserialize<'de> for GeneratedField {
17692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17693 where
17694 D: serde::Deserializer<'de>,
17695 {
17696 struct GeneratedVisitor;
17697
17698 impl serde::de::Visitor<'_> for GeneratedVisitor {
17699 type Value = GeneratedField;
17700
17701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17702 write!(formatter, "expected one of: {:?}", &FIELDS)
17703 }
17704
17705 #[allow(unused_variables)]
17706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17707 where
17708 E: serde::de::Error,
17709 {
17710 match value {
17711 "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
17712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17713 }
17714 }
17715 }
17716 deserializer.deserialize_identifier(GeneratedVisitor)
17717 }
17718 }
17719 struct GeneratedVisitor;
17720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17721 type Value = VacuumTask;
17722
17723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17724 formatter.write_str("struct hummock.VacuumTask")
17725 }
17726
17727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
17728 where
17729 V: serde::de::MapAccess<'de>,
17730 {
17731 let mut sstable_object_ids__ = None;
17732 while let Some(k) = map_.next_key()? {
17733 match k {
17734 GeneratedField::SstableObjectIds => {
17735 if sstable_object_ids__.is_some() {
17736 return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
17737 }
17738 sstable_object_ids__ =
17739 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17740 .into_iter().map(|x| x.0).collect())
17741 ;
17742 }
17743 }
17744 }
17745 Ok(VacuumTask {
17746 sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
17747 })
17748 }
17749 }
17750 deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
17751 }
17752}
17753impl serde::Serialize for ValidationTask {
17754 #[allow(deprecated)]
17755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17756 where
17757 S: serde::Serializer,
17758 {
17759 use serde::ser::SerializeStruct;
17760 let mut len = 0;
17761 if !self.sst_infos.is_empty() {
17762 len += 1;
17763 }
17764 if !self.sst_id_to_worker_id.is_empty() {
17765 len += 1;
17766 }
17767 let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
17768 if !self.sst_infos.is_empty() {
17769 struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
17770 }
17771 if !self.sst_id_to_worker_id.is_empty() {
17772 struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
17773 }
17774 struct_ser.end()
17775 }
17776}
17777impl<'de> serde::Deserialize<'de> for ValidationTask {
17778 #[allow(deprecated)]
17779 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17780 where
17781 D: serde::Deserializer<'de>,
17782 {
17783 const FIELDS: &[&str] = &[
17784 "sst_infos",
17785 "sstInfos",
17786 "sst_id_to_worker_id",
17787 "sstIdToWorkerId",
17788 ];
17789
17790 #[allow(clippy::enum_variant_names)]
17791 enum GeneratedField {
17792 SstInfos,
17793 SstIdToWorkerId,
17794 }
17795 impl<'de> serde::Deserialize<'de> for GeneratedField {
17796 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17797 where
17798 D: serde::Deserializer<'de>,
17799 {
17800 struct GeneratedVisitor;
17801
17802 impl serde::de::Visitor<'_> for GeneratedVisitor {
17803 type Value = GeneratedField;
17804
17805 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17806 write!(formatter, "expected one of: {:?}", &FIELDS)
17807 }
17808
17809 #[allow(unused_variables)]
17810 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17811 where
17812 E: serde::de::Error,
17813 {
17814 match value {
17815 "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
17816 "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
17817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17818 }
17819 }
17820 }
17821 deserializer.deserialize_identifier(GeneratedVisitor)
17822 }
17823 }
17824 struct GeneratedVisitor;
17825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17826 type Value = ValidationTask;
17827
17828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17829 formatter.write_str("struct hummock.ValidationTask")
17830 }
17831
17832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
17833 where
17834 V: serde::de::MapAccess<'de>,
17835 {
17836 let mut sst_infos__ = None;
17837 let mut sst_id_to_worker_id__ = None;
17838 while let Some(k) = map_.next_key()? {
17839 match k {
17840 GeneratedField::SstInfos => {
17841 if sst_infos__.is_some() {
17842 return Err(serde::de::Error::duplicate_field("sstInfos"));
17843 }
17844 sst_infos__ = Some(map_.next_value()?);
17845 }
17846 GeneratedField::SstIdToWorkerId => {
17847 if sst_id_to_worker_id__.is_some() {
17848 return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
17849 }
17850 sst_id_to_worker_id__ = Some(
17851 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
17852 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
17853 );
17854 }
17855 }
17856 }
17857 Ok(ValidationTask {
17858 sst_infos: sst_infos__.unwrap_or_default(),
17859 sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
17860 })
17861 }
17862 }
17863 deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
17864 }
17865}
17866impl serde::Serialize for VectorFileInfo {
17867 #[allow(deprecated)]
17868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17869 where
17870 S: serde::Serializer,
17871 {
17872 use serde::ser::SerializeStruct;
17873 let mut len = 0;
17874 if self.object_id != 0 {
17875 len += 1;
17876 }
17877 if self.file_size != 0 {
17878 len += 1;
17879 }
17880 if self.start_vector_id != 0 {
17881 len += 1;
17882 }
17883 if self.vector_count != 0 {
17884 len += 1;
17885 }
17886 if self.meta_offset != 0 {
17887 len += 1;
17888 }
17889 let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
17890 if self.object_id != 0 {
17891 #[allow(clippy::needless_borrow)]
17892 #[allow(clippy::needless_borrows_for_generic_args)]
17893 struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
17894 }
17895 if self.file_size != 0 {
17896 #[allow(clippy::needless_borrow)]
17897 #[allow(clippy::needless_borrows_for_generic_args)]
17898 struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
17899 }
17900 if self.start_vector_id != 0 {
17901 #[allow(clippy::needless_borrow)]
17902 #[allow(clippy::needless_borrows_for_generic_args)]
17903 struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
17904 }
17905 if self.vector_count != 0 {
17906 struct_ser.serialize_field("vectorCount", &self.vector_count)?;
17907 }
17908 if self.meta_offset != 0 {
17909 #[allow(clippy::needless_borrow)]
17910 #[allow(clippy::needless_borrows_for_generic_args)]
17911 struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
17912 }
17913 struct_ser.end()
17914 }
17915}
17916impl<'de> serde::Deserialize<'de> for VectorFileInfo {
17917 #[allow(deprecated)]
17918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17919 where
17920 D: serde::Deserializer<'de>,
17921 {
17922 const FIELDS: &[&str] = &[
17923 "object_id",
17924 "objectId",
17925 "file_size",
17926 "fileSize",
17927 "start_vector_id",
17928 "startVectorId",
17929 "vector_count",
17930 "vectorCount",
17931 "meta_offset",
17932 "metaOffset",
17933 ];
17934
17935 #[allow(clippy::enum_variant_names)]
17936 enum GeneratedField {
17937 ObjectId,
17938 FileSize,
17939 StartVectorId,
17940 VectorCount,
17941 MetaOffset,
17942 }
17943 impl<'de> serde::Deserialize<'de> for GeneratedField {
17944 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17945 where
17946 D: serde::Deserializer<'de>,
17947 {
17948 struct GeneratedVisitor;
17949
17950 impl serde::de::Visitor<'_> for GeneratedVisitor {
17951 type Value = GeneratedField;
17952
17953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17954 write!(formatter, "expected one of: {:?}", &FIELDS)
17955 }
17956
17957 #[allow(unused_variables)]
17958 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17959 where
17960 E: serde::de::Error,
17961 {
17962 match value {
17963 "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
17964 "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
17965 "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
17966 "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
17967 "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
17968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17969 }
17970 }
17971 }
17972 deserializer.deserialize_identifier(GeneratedVisitor)
17973 }
17974 }
17975 struct GeneratedVisitor;
17976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17977 type Value = VectorFileInfo;
17978
17979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17980 formatter.write_str("struct hummock.VectorFileInfo")
17981 }
17982
17983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
17984 where
17985 V: serde::de::MapAccess<'de>,
17986 {
17987 let mut object_id__ = None;
17988 let mut file_size__ = None;
17989 let mut start_vector_id__ = None;
17990 let mut vector_count__ = None;
17991 let mut meta_offset__ = None;
17992 while let Some(k) = map_.next_key()? {
17993 match k {
17994 GeneratedField::ObjectId => {
17995 if object_id__.is_some() {
17996 return Err(serde::de::Error::duplicate_field("objectId"));
17997 }
17998 object_id__ =
17999 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18000 ;
18001 }
18002 GeneratedField::FileSize => {
18003 if file_size__.is_some() {
18004 return Err(serde::de::Error::duplicate_field("fileSize"));
18005 }
18006 file_size__ =
18007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18008 ;
18009 }
18010 GeneratedField::StartVectorId => {
18011 if start_vector_id__.is_some() {
18012 return Err(serde::de::Error::duplicate_field("startVectorId"));
18013 }
18014 start_vector_id__ =
18015 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18016 ;
18017 }
18018 GeneratedField::VectorCount => {
18019 if vector_count__.is_some() {
18020 return Err(serde::de::Error::duplicate_field("vectorCount"));
18021 }
18022 vector_count__ =
18023 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18024 ;
18025 }
18026 GeneratedField::MetaOffset => {
18027 if meta_offset__.is_some() {
18028 return Err(serde::de::Error::duplicate_field("metaOffset"));
18029 }
18030 meta_offset__ =
18031 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18032 ;
18033 }
18034 }
18035 }
18036 Ok(VectorFileInfo {
18037 object_id: object_id__.unwrap_or_default(),
18038 file_size: file_size__.unwrap_or_default(),
18039 start_vector_id: start_vector_id__.unwrap_or_default(),
18040 vector_count: vector_count__.unwrap_or_default(),
18041 meta_offset: meta_offset__.unwrap_or_default(),
18042 })
18043 }
18044 }
18045 deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
18046 }
18047}
18048impl serde::Serialize for VectorIndex {
18049 #[allow(deprecated)]
18050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18051 where
18052 S: serde::Serializer,
18053 {
18054 use serde::ser::SerializeStruct;
18055 let mut len = 0;
18056 if self.dimension != 0 {
18057 len += 1;
18058 }
18059 if self.distance_type != 0 {
18060 len += 1;
18061 }
18062 if self.variant.is_some() {
18063 len += 1;
18064 }
18065 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
18066 if self.dimension != 0 {
18067 struct_ser.serialize_field("dimension", &self.dimension)?;
18068 }
18069 if self.distance_type != 0 {
18070 let v = super::common::DistanceType::try_from(self.distance_type)
18071 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
18072 struct_ser.serialize_field("distanceType", &v)?;
18073 }
18074 if let Some(v) = self.variant.as_ref() {
18075 match v {
18076 vector_index::Variant::Flat(v) => {
18077 struct_ser.serialize_field("flat", v)?;
18078 }
18079 vector_index::Variant::HnswFlat(v) => {
18080 struct_ser.serialize_field("hnswFlat", v)?;
18081 }
18082 }
18083 }
18084 struct_ser.end()
18085 }
18086}
18087impl<'de> serde::Deserialize<'de> for VectorIndex {
18088 #[allow(deprecated)]
18089 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18090 where
18091 D: serde::Deserializer<'de>,
18092 {
18093 const FIELDS: &[&str] = &[
18094 "dimension",
18095 "distance_type",
18096 "distanceType",
18097 "flat",
18098 "hnsw_flat",
18099 "hnswFlat",
18100 ];
18101
18102 #[allow(clippy::enum_variant_names)]
18103 enum GeneratedField {
18104 Dimension,
18105 DistanceType,
18106 Flat,
18107 HnswFlat,
18108 }
18109 impl<'de> serde::Deserialize<'de> for GeneratedField {
18110 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18111 where
18112 D: serde::Deserializer<'de>,
18113 {
18114 struct GeneratedVisitor;
18115
18116 impl serde::de::Visitor<'_> for GeneratedVisitor {
18117 type Value = GeneratedField;
18118
18119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18120 write!(formatter, "expected one of: {:?}", &FIELDS)
18121 }
18122
18123 #[allow(unused_variables)]
18124 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18125 where
18126 E: serde::de::Error,
18127 {
18128 match value {
18129 "dimension" => Ok(GeneratedField::Dimension),
18130 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
18131 "flat" => Ok(GeneratedField::Flat),
18132 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
18133 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18134 }
18135 }
18136 }
18137 deserializer.deserialize_identifier(GeneratedVisitor)
18138 }
18139 }
18140 struct GeneratedVisitor;
18141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18142 type Value = VectorIndex;
18143
18144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18145 formatter.write_str("struct hummock.VectorIndex")
18146 }
18147
18148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
18149 where
18150 V: serde::de::MapAccess<'de>,
18151 {
18152 let mut dimension__ = None;
18153 let mut distance_type__ = None;
18154 let mut variant__ = None;
18155 while let Some(k) = map_.next_key()? {
18156 match k {
18157 GeneratedField::Dimension => {
18158 if dimension__.is_some() {
18159 return Err(serde::de::Error::duplicate_field("dimension"));
18160 }
18161 dimension__ =
18162 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18163 ;
18164 }
18165 GeneratedField::DistanceType => {
18166 if distance_type__.is_some() {
18167 return Err(serde::de::Error::duplicate_field("distanceType"));
18168 }
18169 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
18170 }
18171 GeneratedField::Flat => {
18172 if variant__.is_some() {
18173 return Err(serde::de::Error::duplicate_field("flat"));
18174 }
18175 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
18176;
18177 }
18178 GeneratedField::HnswFlat => {
18179 if variant__.is_some() {
18180 return Err(serde::de::Error::duplicate_field("hnswFlat"));
18181 }
18182 variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::HnswFlat)
18183;
18184 }
18185 }
18186 }
18187 Ok(VectorIndex {
18188 dimension: dimension__.unwrap_or_default(),
18189 distance_type: distance_type__.unwrap_or_default(),
18190 variant: variant__,
18191 })
18192 }
18193 }
18194 deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
18195 }
18196}
18197impl serde::Serialize for VectorIndexDelta {
18198 #[allow(deprecated)]
18199 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18200 where
18201 S: serde::Serializer,
18202 {
18203 use serde::ser::SerializeStruct;
18204 let mut len = 0;
18205 if self.delta.is_some() {
18206 len += 1;
18207 }
18208 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
18209 if let Some(v) = self.delta.as_ref() {
18210 match v {
18211 vector_index_delta::Delta::Init(v) => {
18212 struct_ser.serialize_field("init", v)?;
18213 }
18214 vector_index_delta::Delta::Adds(v) => {
18215 struct_ser.serialize_field("adds", v)?;
18216 }
18217 }
18218 }
18219 struct_ser.end()
18220 }
18221}
18222impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
18223 #[allow(deprecated)]
18224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18225 where
18226 D: serde::Deserializer<'de>,
18227 {
18228 const FIELDS: &[&str] = &[
18229 "init",
18230 "adds",
18231 ];
18232
18233 #[allow(clippy::enum_variant_names)]
18234 enum GeneratedField {
18235 Init,
18236 Adds,
18237 }
18238 impl<'de> serde::Deserialize<'de> for GeneratedField {
18239 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18240 where
18241 D: serde::Deserializer<'de>,
18242 {
18243 struct GeneratedVisitor;
18244
18245 impl serde::de::Visitor<'_> for GeneratedVisitor {
18246 type Value = GeneratedField;
18247
18248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18249 write!(formatter, "expected one of: {:?}", &FIELDS)
18250 }
18251
18252 #[allow(unused_variables)]
18253 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18254 where
18255 E: serde::de::Error,
18256 {
18257 match value {
18258 "init" => Ok(GeneratedField::Init),
18259 "adds" => Ok(GeneratedField::Adds),
18260 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18261 }
18262 }
18263 }
18264 deserializer.deserialize_identifier(GeneratedVisitor)
18265 }
18266 }
18267 struct GeneratedVisitor;
18268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18269 type Value = VectorIndexDelta;
18270
18271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18272 formatter.write_str("struct hummock.VectorIndexDelta")
18273 }
18274
18275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
18276 where
18277 V: serde::de::MapAccess<'de>,
18278 {
18279 let mut delta__ = None;
18280 while let Some(k) = map_.next_key()? {
18281 match k {
18282 GeneratedField::Init => {
18283 if delta__.is_some() {
18284 return Err(serde::de::Error::duplicate_field("init"));
18285 }
18286 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
18287;
18288 }
18289 GeneratedField::Adds => {
18290 if delta__.is_some() {
18291 return Err(serde::de::Error::duplicate_field("adds"));
18292 }
18293 delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
18294;
18295 }
18296 }
18297 }
18298 Ok(VectorIndexDelta {
18299 delta: delta__,
18300 })
18301 }
18302 }
18303 deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
18304 }
18305}
18306impl serde::Serialize for vector_index_delta::VectorIndexAdd {
18307 #[allow(deprecated)]
18308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18309 where
18310 S: serde::Serializer,
18311 {
18312 use serde::ser::SerializeStruct;
18313 let mut len = 0;
18314 if self.add.is_some() {
18315 len += 1;
18316 }
18317 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
18318 if let Some(v) = self.add.as_ref() {
18319 match v {
18320 vector_index_delta::vector_index_add::Add::Flat(v) => {
18321 struct_ser.serialize_field("flat", v)?;
18322 }
18323 vector_index_delta::vector_index_add::Add::HnswFlat(v) => {
18324 struct_ser.serialize_field("hnswFlat", v)?;
18325 }
18326 }
18327 }
18328 struct_ser.end()
18329 }
18330}
18331impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
18332 #[allow(deprecated)]
18333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18334 where
18335 D: serde::Deserializer<'de>,
18336 {
18337 const FIELDS: &[&str] = &[
18338 "flat",
18339 "hnsw_flat",
18340 "hnswFlat",
18341 ];
18342
18343 #[allow(clippy::enum_variant_names)]
18344 enum GeneratedField {
18345 Flat,
18346 HnswFlat,
18347 }
18348 impl<'de> serde::Deserialize<'de> for GeneratedField {
18349 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18350 where
18351 D: serde::Deserializer<'de>,
18352 {
18353 struct GeneratedVisitor;
18354
18355 impl serde::de::Visitor<'_> for GeneratedVisitor {
18356 type Value = GeneratedField;
18357
18358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18359 write!(formatter, "expected one of: {:?}", &FIELDS)
18360 }
18361
18362 #[allow(unused_variables)]
18363 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18364 where
18365 E: serde::de::Error,
18366 {
18367 match value {
18368 "flat" => Ok(GeneratedField::Flat),
18369 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
18370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18371 }
18372 }
18373 }
18374 deserializer.deserialize_identifier(GeneratedVisitor)
18375 }
18376 }
18377 struct GeneratedVisitor;
18378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18379 type Value = vector_index_delta::VectorIndexAdd;
18380
18381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18382 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
18383 }
18384
18385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
18386 where
18387 V: serde::de::MapAccess<'de>,
18388 {
18389 let mut add__ = None;
18390 while let Some(k) = map_.next_key()? {
18391 match k {
18392 GeneratedField::Flat => {
18393 if add__.is_some() {
18394 return Err(serde::de::Error::duplicate_field("flat"));
18395 }
18396 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
18397;
18398 }
18399 GeneratedField::HnswFlat => {
18400 if add__.is_some() {
18401 return Err(serde::de::Error::duplicate_field("hnswFlat"));
18402 }
18403 add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::HnswFlat)
18404;
18405 }
18406 }
18407 }
18408 Ok(vector_index_delta::VectorIndexAdd {
18409 add: add__,
18410 })
18411 }
18412 }
18413 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
18414 }
18415}
18416impl serde::Serialize for vector_index_delta::VectorIndexAdds {
18417 #[allow(deprecated)]
18418 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18419 where
18420 S: serde::Serializer,
18421 {
18422 use serde::ser::SerializeStruct;
18423 let mut len = 0;
18424 if !self.adds.is_empty() {
18425 len += 1;
18426 }
18427 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
18428 if !self.adds.is_empty() {
18429 struct_ser.serialize_field("adds", &self.adds)?;
18430 }
18431 struct_ser.end()
18432 }
18433}
18434impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
18435 #[allow(deprecated)]
18436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18437 where
18438 D: serde::Deserializer<'de>,
18439 {
18440 const FIELDS: &[&str] = &[
18441 "adds",
18442 ];
18443
18444 #[allow(clippy::enum_variant_names)]
18445 enum GeneratedField {
18446 Adds,
18447 }
18448 impl<'de> serde::Deserialize<'de> for GeneratedField {
18449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18450 where
18451 D: serde::Deserializer<'de>,
18452 {
18453 struct GeneratedVisitor;
18454
18455 impl serde::de::Visitor<'_> for GeneratedVisitor {
18456 type Value = GeneratedField;
18457
18458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18459 write!(formatter, "expected one of: {:?}", &FIELDS)
18460 }
18461
18462 #[allow(unused_variables)]
18463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18464 where
18465 E: serde::de::Error,
18466 {
18467 match value {
18468 "adds" => Ok(GeneratedField::Adds),
18469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18470 }
18471 }
18472 }
18473 deserializer.deserialize_identifier(GeneratedVisitor)
18474 }
18475 }
18476 struct GeneratedVisitor;
18477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18478 type Value = vector_index_delta::VectorIndexAdds;
18479
18480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18481 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
18482 }
18483
18484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
18485 where
18486 V: serde::de::MapAccess<'de>,
18487 {
18488 let mut adds__ = None;
18489 while let Some(k) = map_.next_key()? {
18490 match k {
18491 GeneratedField::Adds => {
18492 if adds__.is_some() {
18493 return Err(serde::de::Error::duplicate_field("adds"));
18494 }
18495 adds__ = Some(map_.next_value()?);
18496 }
18497 }
18498 }
18499 Ok(vector_index_delta::VectorIndexAdds {
18500 adds: adds__.unwrap_or_default(),
18501 })
18502 }
18503 }
18504 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
18505 }
18506}
18507impl serde::Serialize for vector_index_delta::VectorIndexInit {
18508 #[allow(deprecated)]
18509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18510 where
18511 S: serde::Serializer,
18512 {
18513 use serde::ser::SerializeStruct;
18514 let mut len = 0;
18515 if self.info.is_some() {
18516 len += 1;
18517 }
18518 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
18519 if let Some(v) = self.info.as_ref() {
18520 struct_ser.serialize_field("info", v)?;
18521 }
18522 struct_ser.end()
18523 }
18524}
18525impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
18526 #[allow(deprecated)]
18527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18528 where
18529 D: serde::Deserializer<'de>,
18530 {
18531 const FIELDS: &[&str] = &[
18532 "info",
18533 ];
18534
18535 #[allow(clippy::enum_variant_names)]
18536 enum GeneratedField {
18537 Info,
18538 }
18539 impl<'de> serde::Deserialize<'de> for GeneratedField {
18540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18541 where
18542 D: serde::Deserializer<'de>,
18543 {
18544 struct GeneratedVisitor;
18545
18546 impl serde::de::Visitor<'_> for GeneratedVisitor {
18547 type Value = GeneratedField;
18548
18549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18550 write!(formatter, "expected one of: {:?}", &FIELDS)
18551 }
18552
18553 #[allow(unused_variables)]
18554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18555 where
18556 E: serde::de::Error,
18557 {
18558 match value {
18559 "info" => Ok(GeneratedField::Info),
18560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18561 }
18562 }
18563 }
18564 deserializer.deserialize_identifier(GeneratedVisitor)
18565 }
18566 }
18567 struct GeneratedVisitor;
18568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18569 type Value = vector_index_delta::VectorIndexInit;
18570
18571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18572 formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
18573 }
18574
18575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
18576 where
18577 V: serde::de::MapAccess<'de>,
18578 {
18579 let mut info__ = None;
18580 while let Some(k) = map_.next_key()? {
18581 match k {
18582 GeneratedField::Info => {
18583 if info__.is_some() {
18584 return Err(serde::de::Error::duplicate_field("info"));
18585 }
18586 info__ = map_.next_value()?;
18587 }
18588 }
18589 }
18590 Ok(vector_index_delta::VectorIndexInit {
18591 info: info__,
18592 })
18593 }
18594 }
18595 deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
18596 }
18597}
18598impl serde::Serialize for VectorIndexObject {
18599 #[allow(deprecated)]
18600 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18601 where
18602 S: serde::Serializer,
18603 {
18604 use serde::ser::SerializeStruct;
18605 let mut len = 0;
18606 if self.id != 0 {
18607 len += 1;
18608 }
18609 if self.object_type != 0 {
18610 len += 1;
18611 }
18612 let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
18613 if self.id != 0 {
18614 #[allow(clippy::needless_borrow)]
18615 #[allow(clippy::needless_borrows_for_generic_args)]
18616 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
18617 }
18618 if self.object_type != 0 {
18619 let v = VectorIndexObjectType::try_from(self.object_type)
18620 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
18621 struct_ser.serialize_field("objectType", &v)?;
18622 }
18623 struct_ser.end()
18624 }
18625}
18626impl<'de> serde::Deserialize<'de> for VectorIndexObject {
18627 #[allow(deprecated)]
18628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18629 where
18630 D: serde::Deserializer<'de>,
18631 {
18632 const FIELDS: &[&str] = &[
18633 "id",
18634 "object_type",
18635 "objectType",
18636 ];
18637
18638 #[allow(clippy::enum_variant_names)]
18639 enum GeneratedField {
18640 Id,
18641 ObjectType,
18642 }
18643 impl<'de> serde::Deserialize<'de> for GeneratedField {
18644 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18645 where
18646 D: serde::Deserializer<'de>,
18647 {
18648 struct GeneratedVisitor;
18649
18650 impl serde::de::Visitor<'_> for GeneratedVisitor {
18651 type Value = GeneratedField;
18652
18653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18654 write!(formatter, "expected one of: {:?}", &FIELDS)
18655 }
18656
18657 #[allow(unused_variables)]
18658 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18659 where
18660 E: serde::de::Error,
18661 {
18662 match value {
18663 "id" => Ok(GeneratedField::Id),
18664 "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
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 = VectorIndexObject;
18675
18676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18677 formatter.write_str("struct hummock.VectorIndexObject")
18678 }
18679
18680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
18681 where
18682 V: serde::de::MapAccess<'de>,
18683 {
18684 let mut id__ = None;
18685 let mut object_type__ = None;
18686 while let Some(k) = map_.next_key()? {
18687 match k {
18688 GeneratedField::Id => {
18689 if id__.is_some() {
18690 return Err(serde::de::Error::duplicate_field("id"));
18691 }
18692 id__ =
18693 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18694 ;
18695 }
18696 GeneratedField::ObjectType => {
18697 if object_type__.is_some() {
18698 return Err(serde::de::Error::duplicate_field("objectType"));
18699 }
18700 object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
18701 }
18702 }
18703 }
18704 Ok(VectorIndexObject {
18705 id: id__.unwrap_or_default(),
18706 object_type: object_type__.unwrap_or_default(),
18707 })
18708 }
18709 }
18710 deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
18711 }
18712}
18713impl serde::Serialize for VectorIndexObjectType {
18714 #[allow(deprecated)]
18715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18716 where
18717 S: serde::Serializer,
18718 {
18719 let variant = match self {
18720 Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
18721 Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
18722 Self::VectorIndexObjectHnswGraph => "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
18723 };
18724 serializer.serialize_str(variant)
18725 }
18726}
18727impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
18728 #[allow(deprecated)]
18729 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18730 where
18731 D: serde::Deserializer<'de>,
18732 {
18733 const FIELDS: &[&str] = &[
18734 "VECTOR_INDEX_OBJECT_UNSPECIFIED",
18735 "VECTOR_INDEX_OBJECT_VECTOR",
18736 "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
18737 ];
18738
18739 struct GeneratedVisitor;
18740
18741 impl serde::de::Visitor<'_> for GeneratedVisitor {
18742 type Value = VectorIndexObjectType;
18743
18744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18745 write!(formatter, "expected one of: {:?}", &FIELDS)
18746 }
18747
18748 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18749 where
18750 E: serde::de::Error,
18751 {
18752 i32::try_from(v)
18753 .ok()
18754 .and_then(|x| x.try_into().ok())
18755 .ok_or_else(|| {
18756 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18757 })
18758 }
18759
18760 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18761 where
18762 E: serde::de::Error,
18763 {
18764 i32::try_from(v)
18765 .ok()
18766 .and_then(|x| x.try_into().ok())
18767 .ok_or_else(|| {
18768 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18769 })
18770 }
18771
18772 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18773 where
18774 E: serde::de::Error,
18775 {
18776 match value {
18777 "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
18778 "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
18779 "VECTOR_INDEX_OBJECT_HNSW_GRAPH" => Ok(VectorIndexObjectType::VectorIndexObjectHnswGraph),
18780 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18781 }
18782 }
18783 }
18784 deserializer.deserialize_any(GeneratedVisitor)
18785 }
18786}
18787impl serde::Serialize for VersionUpdatePayload {
18788 #[allow(deprecated)]
18789 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18790 where
18791 S: serde::Serializer,
18792 {
18793 use serde::ser::SerializeStruct;
18794 let mut len = 0;
18795 if self.payload.is_some() {
18796 len += 1;
18797 }
18798 let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
18799 if let Some(v) = self.payload.as_ref() {
18800 match v {
18801 version_update_payload::Payload::VersionDeltas(v) => {
18802 struct_ser.serialize_field("versionDeltas", v)?;
18803 }
18804 version_update_payload::Payload::PinnedVersion(v) => {
18805 struct_ser.serialize_field("pinnedVersion", v)?;
18806 }
18807 }
18808 }
18809 struct_ser.end()
18810 }
18811}
18812impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
18813 #[allow(deprecated)]
18814 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18815 where
18816 D: serde::Deserializer<'de>,
18817 {
18818 const FIELDS: &[&str] = &[
18819 "version_deltas",
18820 "versionDeltas",
18821 "pinned_version",
18822 "pinnedVersion",
18823 ];
18824
18825 #[allow(clippy::enum_variant_names)]
18826 enum GeneratedField {
18827 VersionDeltas,
18828 PinnedVersion,
18829 }
18830 impl<'de> serde::Deserialize<'de> for GeneratedField {
18831 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18832 where
18833 D: serde::Deserializer<'de>,
18834 {
18835 struct GeneratedVisitor;
18836
18837 impl serde::de::Visitor<'_> for GeneratedVisitor {
18838 type Value = GeneratedField;
18839
18840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18841 write!(formatter, "expected one of: {:?}", &FIELDS)
18842 }
18843
18844 #[allow(unused_variables)]
18845 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18846 where
18847 E: serde::de::Error,
18848 {
18849 match value {
18850 "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
18851 "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
18852 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18853 }
18854 }
18855 }
18856 deserializer.deserialize_identifier(GeneratedVisitor)
18857 }
18858 }
18859 struct GeneratedVisitor;
18860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18861 type Value = VersionUpdatePayload;
18862
18863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18864 formatter.write_str("struct hummock.VersionUpdatePayload")
18865 }
18866
18867 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
18868 where
18869 V: serde::de::MapAccess<'de>,
18870 {
18871 let mut payload__ = None;
18872 while let Some(k) = map_.next_key()? {
18873 match k {
18874 GeneratedField::VersionDeltas => {
18875 if payload__.is_some() {
18876 return Err(serde::de::Error::duplicate_field("versionDeltas"));
18877 }
18878 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
18879;
18880 }
18881 GeneratedField::PinnedVersion => {
18882 if payload__.is_some() {
18883 return Err(serde::de::Error::duplicate_field("pinnedVersion"));
18884 }
18885 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
18886;
18887 }
18888 }
18889 }
18890 Ok(VersionUpdatePayload {
18891 payload: payload__,
18892 })
18893 }
18894 }
18895 deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
18896 }
18897}
18898impl serde::Serialize for VnodeStatistics {
18899 #[allow(deprecated)]
18900 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18901 where
18902 S: serde::Serializer,
18903 {
18904 use serde::ser::SerializeStruct;
18905 let mut len = 0;
18906 if !self.vnode_user_key_ranges.is_empty() {
18907 len += 1;
18908 }
18909 let mut struct_ser = serializer.serialize_struct("hummock.VnodeStatistics", len)?;
18910 if !self.vnode_user_key_ranges.is_empty() {
18911 struct_ser.serialize_field("vnodeUserKeyRanges", &self.vnode_user_key_ranges)?;
18912 }
18913 struct_ser.end()
18914 }
18915}
18916impl<'de> serde::Deserialize<'de> for VnodeStatistics {
18917 #[allow(deprecated)]
18918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18919 where
18920 D: serde::Deserializer<'de>,
18921 {
18922 const FIELDS: &[&str] = &[
18923 "vnode_user_key_ranges",
18924 "vnodeUserKeyRanges",
18925 ];
18926
18927 #[allow(clippy::enum_variant_names)]
18928 enum GeneratedField {
18929 VnodeUserKeyRanges,
18930 }
18931 impl<'de> serde::Deserialize<'de> for GeneratedField {
18932 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18933 where
18934 D: serde::Deserializer<'de>,
18935 {
18936 struct GeneratedVisitor;
18937
18938 impl serde::de::Visitor<'_> for GeneratedVisitor {
18939 type Value = GeneratedField;
18940
18941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18942 write!(formatter, "expected one of: {:?}", &FIELDS)
18943 }
18944
18945 #[allow(unused_variables)]
18946 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18947 where
18948 E: serde::de::Error,
18949 {
18950 match value {
18951 "vnodeUserKeyRanges" | "vnode_user_key_ranges" => Ok(GeneratedField::VnodeUserKeyRanges),
18952 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18953 }
18954 }
18955 }
18956 deserializer.deserialize_identifier(GeneratedVisitor)
18957 }
18958 }
18959 struct GeneratedVisitor;
18960 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18961 type Value = VnodeStatistics;
18962
18963 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18964 formatter.write_str("struct hummock.VnodeStatistics")
18965 }
18966
18967 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeStatistics, V::Error>
18968 where
18969 V: serde::de::MapAccess<'de>,
18970 {
18971 let mut vnode_user_key_ranges__ = None;
18972 while let Some(k) = map_.next_key()? {
18973 match k {
18974 GeneratedField::VnodeUserKeyRanges => {
18975 if vnode_user_key_ranges__.is_some() {
18976 return Err(serde::de::Error::duplicate_field("vnodeUserKeyRanges"));
18977 }
18978 vnode_user_key_ranges__ = Some(
18979 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
18980 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
18981 );
18982 }
18983 }
18984 }
18985 Ok(VnodeStatistics {
18986 vnode_user_key_ranges: vnode_user_key_ranges__.unwrap_or_default(),
18987 })
18988 }
18989 }
18990 deserializer.deserialize_struct("hummock.VnodeStatistics", FIELDS, GeneratedVisitor)
18991 }
18992}
18993impl serde::Serialize for VnodeUserKeyRange {
18994 #[allow(deprecated)]
18995 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18996 where
18997 S: serde::Serializer,
18998 {
18999 use serde::ser::SerializeStruct;
19000 let mut len = 0;
19001 if !self.min_key.is_empty() {
19002 len += 1;
19003 }
19004 if !self.max_key.is_empty() {
19005 len += 1;
19006 }
19007 let mut struct_ser = serializer.serialize_struct("hummock.VnodeUserKeyRange", len)?;
19008 if !self.min_key.is_empty() {
19009 #[allow(clippy::needless_borrow)]
19010 #[allow(clippy::needless_borrows_for_generic_args)]
19011 struct_ser.serialize_field("minKey", pbjson::private::base64::encode(&self.min_key).as_str())?;
19012 }
19013 if !self.max_key.is_empty() {
19014 #[allow(clippy::needless_borrow)]
19015 #[allow(clippy::needless_borrows_for_generic_args)]
19016 struct_ser.serialize_field("maxKey", pbjson::private::base64::encode(&self.max_key).as_str())?;
19017 }
19018 struct_ser.end()
19019 }
19020}
19021impl<'de> serde::Deserialize<'de> for VnodeUserKeyRange {
19022 #[allow(deprecated)]
19023 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19024 where
19025 D: serde::Deserializer<'de>,
19026 {
19027 const FIELDS: &[&str] = &[
19028 "min_key",
19029 "minKey",
19030 "max_key",
19031 "maxKey",
19032 ];
19033
19034 #[allow(clippy::enum_variant_names)]
19035 enum GeneratedField {
19036 MinKey,
19037 MaxKey,
19038 }
19039 impl<'de> serde::Deserialize<'de> for GeneratedField {
19040 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19041 where
19042 D: serde::Deserializer<'de>,
19043 {
19044 struct GeneratedVisitor;
19045
19046 impl serde::de::Visitor<'_> for GeneratedVisitor {
19047 type Value = GeneratedField;
19048
19049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19050 write!(formatter, "expected one of: {:?}", &FIELDS)
19051 }
19052
19053 #[allow(unused_variables)]
19054 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19055 where
19056 E: serde::de::Error,
19057 {
19058 match value {
19059 "minKey" | "min_key" => Ok(GeneratedField::MinKey),
19060 "maxKey" | "max_key" => Ok(GeneratedField::MaxKey),
19061 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19062 }
19063 }
19064 }
19065 deserializer.deserialize_identifier(GeneratedVisitor)
19066 }
19067 }
19068 struct GeneratedVisitor;
19069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19070 type Value = VnodeUserKeyRange;
19071
19072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19073 formatter.write_str("struct hummock.VnodeUserKeyRange")
19074 }
19075
19076 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeUserKeyRange, V::Error>
19077 where
19078 V: serde::de::MapAccess<'de>,
19079 {
19080 let mut min_key__ = None;
19081 let mut max_key__ = None;
19082 while let Some(k) = map_.next_key()? {
19083 match k {
19084 GeneratedField::MinKey => {
19085 if min_key__.is_some() {
19086 return Err(serde::de::Error::duplicate_field("minKey"));
19087 }
19088 min_key__ =
19089 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
19090 ;
19091 }
19092 GeneratedField::MaxKey => {
19093 if max_key__.is_some() {
19094 return Err(serde::de::Error::duplicate_field("maxKey"));
19095 }
19096 max_key__ =
19097 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
19098 ;
19099 }
19100 }
19101 }
19102 Ok(VnodeUserKeyRange {
19103 min_key: min_key__.unwrap_or_default(),
19104 max_key: max_key__.unwrap_or_default(),
19105 })
19106 }
19107 }
19108 deserializer.deserialize_struct("hummock.VnodeUserKeyRange", FIELDS, GeneratedVisitor)
19109 }
19110}
19111impl serde::Serialize for VnodeWatermark {
19112 #[allow(deprecated)]
19113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19114 where
19115 S: serde::Serializer,
19116 {
19117 use serde::ser::SerializeStruct;
19118 let mut len = 0;
19119 if !self.watermark.is_empty() {
19120 len += 1;
19121 }
19122 if self.vnode_bitmap.is_some() {
19123 len += 1;
19124 }
19125 let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
19126 if !self.watermark.is_empty() {
19127 #[allow(clippy::needless_borrow)]
19128 #[allow(clippy::needless_borrows_for_generic_args)]
19129 struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
19130 }
19131 if let Some(v) = self.vnode_bitmap.as_ref() {
19132 struct_ser.serialize_field("vnodeBitmap", v)?;
19133 }
19134 struct_ser.end()
19135 }
19136}
19137impl<'de> serde::Deserialize<'de> for VnodeWatermark {
19138 #[allow(deprecated)]
19139 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19140 where
19141 D: serde::Deserializer<'de>,
19142 {
19143 const FIELDS: &[&str] = &[
19144 "watermark",
19145 "vnode_bitmap",
19146 "vnodeBitmap",
19147 ];
19148
19149 #[allow(clippy::enum_variant_names)]
19150 enum GeneratedField {
19151 Watermark,
19152 VnodeBitmap,
19153 }
19154 impl<'de> serde::Deserialize<'de> for GeneratedField {
19155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19156 where
19157 D: serde::Deserializer<'de>,
19158 {
19159 struct GeneratedVisitor;
19160
19161 impl serde::de::Visitor<'_> for GeneratedVisitor {
19162 type Value = GeneratedField;
19163
19164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19165 write!(formatter, "expected one of: {:?}", &FIELDS)
19166 }
19167
19168 #[allow(unused_variables)]
19169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19170 where
19171 E: serde::de::Error,
19172 {
19173 match value {
19174 "watermark" => Ok(GeneratedField::Watermark),
19175 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
19176 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19177 }
19178 }
19179 }
19180 deserializer.deserialize_identifier(GeneratedVisitor)
19181 }
19182 }
19183 struct GeneratedVisitor;
19184 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19185 type Value = VnodeWatermark;
19186
19187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19188 formatter.write_str("struct hummock.VnodeWatermark")
19189 }
19190
19191 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
19192 where
19193 V: serde::de::MapAccess<'de>,
19194 {
19195 let mut watermark__ = None;
19196 let mut vnode_bitmap__ = None;
19197 while let Some(k) = map_.next_key()? {
19198 match k {
19199 GeneratedField::Watermark => {
19200 if watermark__.is_some() {
19201 return Err(serde::de::Error::duplicate_field("watermark"));
19202 }
19203 watermark__ =
19204 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
19205 ;
19206 }
19207 GeneratedField::VnodeBitmap => {
19208 if vnode_bitmap__.is_some() {
19209 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
19210 }
19211 vnode_bitmap__ = map_.next_value()?;
19212 }
19213 }
19214 }
19215 Ok(VnodeWatermark {
19216 watermark: watermark__.unwrap_or_default(),
19217 vnode_bitmap: vnode_bitmap__,
19218 })
19219 }
19220 }
19221 deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
19222 }
19223}
19224impl serde::Serialize for WatermarkSerdeType {
19225 #[allow(deprecated)]
19226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19227 where
19228 S: serde::Serializer,
19229 {
19230 let variant = match self {
19231 Self::TypeUnspecified => "TYPE_UNSPECIFIED",
19232 Self::PkPrefix => "PK_PREFIX",
19233 Self::NonPkPrefix => "NON_PK_PREFIX",
19234 Self::Value => "VALUE",
19235 };
19236 serializer.serialize_str(variant)
19237 }
19238}
19239impl<'de> serde::Deserialize<'de> for WatermarkSerdeType {
19240 #[allow(deprecated)]
19241 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19242 where
19243 D: serde::Deserializer<'de>,
19244 {
19245 const FIELDS: &[&str] = &[
19246 "TYPE_UNSPECIFIED",
19247 "PK_PREFIX",
19248 "NON_PK_PREFIX",
19249 "VALUE",
19250 ];
19251
19252 struct GeneratedVisitor;
19253
19254 impl serde::de::Visitor<'_> for GeneratedVisitor {
19255 type Value = WatermarkSerdeType;
19256
19257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19258 write!(formatter, "expected one of: {:?}", &FIELDS)
19259 }
19260
19261 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
19262 where
19263 E: serde::de::Error,
19264 {
19265 i32::try_from(v)
19266 .ok()
19267 .and_then(|x| x.try_into().ok())
19268 .ok_or_else(|| {
19269 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
19270 })
19271 }
19272
19273 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
19274 where
19275 E: serde::de::Error,
19276 {
19277 i32::try_from(v)
19278 .ok()
19279 .and_then(|x| x.try_into().ok())
19280 .ok_or_else(|| {
19281 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
19282 })
19283 }
19284
19285 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
19286 where
19287 E: serde::de::Error,
19288 {
19289 match value {
19290 "TYPE_UNSPECIFIED" => Ok(WatermarkSerdeType::TypeUnspecified),
19291 "PK_PREFIX" => Ok(WatermarkSerdeType::PkPrefix),
19292 "NON_PK_PREFIX" => Ok(WatermarkSerdeType::NonPkPrefix),
19293 "VALUE" => Ok(WatermarkSerdeType::Value),
19294 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
19295 }
19296 }
19297 }
19298 deserializer.deserialize_any(GeneratedVisitor)
19299 }
19300}
19301impl serde::Serialize for WriteLimits {
19302 #[allow(deprecated)]
19303 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19304 where
19305 S: serde::Serializer,
19306 {
19307 use serde::ser::SerializeStruct;
19308 let mut len = 0;
19309 if !self.write_limits.is_empty() {
19310 len += 1;
19311 }
19312 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
19313 if !self.write_limits.is_empty() {
19314 struct_ser.serialize_field("writeLimits", &self.write_limits)?;
19315 }
19316 struct_ser.end()
19317 }
19318}
19319impl<'de> serde::Deserialize<'de> for WriteLimits {
19320 #[allow(deprecated)]
19321 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19322 where
19323 D: serde::Deserializer<'de>,
19324 {
19325 const FIELDS: &[&str] = &[
19326 "write_limits",
19327 "writeLimits",
19328 ];
19329
19330 #[allow(clippy::enum_variant_names)]
19331 enum GeneratedField {
19332 WriteLimits,
19333 }
19334 impl<'de> serde::Deserialize<'de> for GeneratedField {
19335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19336 where
19337 D: serde::Deserializer<'de>,
19338 {
19339 struct GeneratedVisitor;
19340
19341 impl serde::de::Visitor<'_> for GeneratedVisitor {
19342 type Value = GeneratedField;
19343
19344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19345 write!(formatter, "expected one of: {:?}", &FIELDS)
19346 }
19347
19348 #[allow(unused_variables)]
19349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19350 where
19351 E: serde::de::Error,
19352 {
19353 match value {
19354 "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
19355 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19356 }
19357 }
19358 }
19359 deserializer.deserialize_identifier(GeneratedVisitor)
19360 }
19361 }
19362 struct GeneratedVisitor;
19363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19364 type Value = WriteLimits;
19365
19366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19367 formatter.write_str("struct hummock.WriteLimits")
19368 }
19369
19370 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
19371 where
19372 V: serde::de::MapAccess<'de>,
19373 {
19374 let mut write_limits__ = None;
19375 while let Some(k) = map_.next_key()? {
19376 match k {
19377 GeneratedField::WriteLimits => {
19378 if write_limits__.is_some() {
19379 return Err(serde::de::Error::duplicate_field("writeLimits"));
19380 }
19381 write_limits__ = Some(
19382 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
19383 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19384 );
19385 }
19386 }
19387 }
19388 Ok(WriteLimits {
19389 write_limits: write_limits__.unwrap_or_default(),
19390 })
19391 }
19392 }
19393 deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
19394 }
19395}
19396impl serde::Serialize for write_limits::WriteLimit {
19397 #[allow(deprecated)]
19398 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19399 where
19400 S: serde::Serializer,
19401 {
19402 use serde::ser::SerializeStruct;
19403 let mut len = 0;
19404 if !self.table_ids.is_empty() {
19405 len += 1;
19406 }
19407 if !self.reason.is_empty() {
19408 len += 1;
19409 }
19410 let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
19411 if !self.table_ids.is_empty() {
19412 struct_ser.serialize_field("tableIds", &self.table_ids)?;
19413 }
19414 if !self.reason.is_empty() {
19415 struct_ser.serialize_field("reason", &self.reason)?;
19416 }
19417 struct_ser.end()
19418 }
19419}
19420impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
19421 #[allow(deprecated)]
19422 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19423 where
19424 D: serde::Deserializer<'de>,
19425 {
19426 const FIELDS: &[&str] = &[
19427 "table_ids",
19428 "tableIds",
19429 "reason",
19430 ];
19431
19432 #[allow(clippy::enum_variant_names)]
19433 enum GeneratedField {
19434 TableIds,
19435 Reason,
19436 }
19437 impl<'de> serde::Deserialize<'de> for GeneratedField {
19438 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19439 where
19440 D: serde::Deserializer<'de>,
19441 {
19442 struct GeneratedVisitor;
19443
19444 impl serde::de::Visitor<'_> for GeneratedVisitor {
19445 type Value = GeneratedField;
19446
19447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19448 write!(formatter, "expected one of: {:?}", &FIELDS)
19449 }
19450
19451 #[allow(unused_variables)]
19452 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19453 where
19454 E: serde::de::Error,
19455 {
19456 match value {
19457 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
19458 "reason" => Ok(GeneratedField::Reason),
19459 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19460 }
19461 }
19462 }
19463 deserializer.deserialize_identifier(GeneratedVisitor)
19464 }
19465 }
19466 struct GeneratedVisitor;
19467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19468 type Value = write_limits::WriteLimit;
19469
19470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19471 formatter.write_str("struct hummock.WriteLimits.WriteLimit")
19472 }
19473
19474 fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
19475 where
19476 V: serde::de::MapAccess<'de>,
19477 {
19478 let mut table_ids__ = None;
19479 let mut reason__ = None;
19480 while let Some(k) = map_.next_key()? {
19481 match k {
19482 GeneratedField::TableIds => {
19483 if table_ids__.is_some() {
19484 return Err(serde::de::Error::duplicate_field("tableIds"));
19485 }
19486 table_ids__ =
19487 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19488 .into_iter().map(|x| x.0).collect())
19489 ;
19490 }
19491 GeneratedField::Reason => {
19492 if reason__.is_some() {
19493 return Err(serde::de::Error::duplicate_field("reason"));
19494 }
19495 reason__ = Some(map_.next_value()?);
19496 }
19497 }
19498 }
19499 Ok(write_limits::WriteLimit {
19500 table_ids: table_ids__.unwrap_or_default(),
19501 reason: reason__.unwrap_or_default(),
19502 })
19503 }
19504 }
19505 deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
19506 }
19507}