1use crate::stream_plan::*;
2impl serde::Serialize for ActorMapping {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if !self.original_indices.is_empty() {
11 len += 1;
12 }
13 if !self.data.is_empty() {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
17 if !self.original_indices.is_empty() {
18 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
19 }
20 if !self.data.is_empty() {
21 struct_ser.serialize_field("data", &self.data)?;
22 }
23 struct_ser.end()
24 }
25}
26impl<'de> serde::Deserialize<'de> for ActorMapping {
27 #[allow(deprecated)]
28 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 const FIELDS: &[&str] = &[
33 "original_indices",
34 "originalIndices",
35 "data",
36 ];
37
38 #[allow(clippy::enum_variant_names)]
39 enum GeneratedField {
40 OriginalIndices,
41 Data,
42 }
43 impl<'de> serde::Deserialize<'de> for GeneratedField {
44 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45 where
46 D: serde::Deserializer<'de>,
47 {
48 struct GeneratedVisitor;
49
50 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51 type Value = GeneratedField;
52
53 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(formatter, "expected one of: {:?}", &FIELDS)
55 }
56
57 #[allow(unused_variables)]
58 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59 where
60 E: serde::de::Error,
61 {
62 match value {
63 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
64 "data" => Ok(GeneratedField::Data),
65 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66 }
67 }
68 }
69 deserializer.deserialize_identifier(GeneratedVisitor)
70 }
71 }
72 struct GeneratedVisitor;
73 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74 type Value = ActorMapping;
75
76 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 formatter.write_str("struct stream_plan.ActorMapping")
78 }
79
80 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
81 where
82 V: serde::de::MapAccess<'de>,
83 {
84 let mut original_indices__ = None;
85 let mut data__ = None;
86 while let Some(k) = map_.next_key()? {
87 match k {
88 GeneratedField::OriginalIndices => {
89 if original_indices__.is_some() {
90 return Err(serde::de::Error::duplicate_field("originalIndices"));
91 }
92 original_indices__ =
93 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
94 .into_iter().map(|x| x.0).collect())
95 ;
96 }
97 GeneratedField::Data => {
98 if data__.is_some() {
99 return Err(serde::de::Error::duplicate_field("data"));
100 }
101 data__ =
102 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
103 .into_iter().map(|x| x.0).collect())
104 ;
105 }
106 }
107 }
108 Ok(ActorMapping {
109 original_indices: original_indices__.unwrap_or_default(),
110 data: data__.unwrap_or_default(),
111 })
112 }
113 }
114 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
115 }
116}
117impl serde::Serialize for AddMutation {
118 #[allow(deprecated)]
119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
120 where
121 S: serde::Serializer,
122 {
123 use serde::ser::SerializeStruct;
124 let mut len = 0;
125 if !self.actor_dispatchers.is_empty() {
126 len += 1;
127 }
128 if !self.added_actors.is_empty() {
129 len += 1;
130 }
131 if !self.actor_splits.is_empty() {
132 len += 1;
133 }
134 if self.pause {
135 len += 1;
136 }
137 if !self.subscriptions_to_add.is_empty() {
138 len += 1;
139 }
140 if !self.backfill_nodes_to_pause.is_empty() {
141 len += 1;
142 }
143 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
144 if !self.actor_dispatchers.is_empty() {
145 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
146 }
147 if !self.added_actors.is_empty() {
148 struct_ser.serialize_field("addedActors", &self.added_actors)?;
149 }
150 if !self.actor_splits.is_empty() {
151 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
152 }
153 if self.pause {
154 struct_ser.serialize_field("pause", &self.pause)?;
155 }
156 if !self.subscriptions_to_add.is_empty() {
157 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
158 }
159 if !self.backfill_nodes_to_pause.is_empty() {
160 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
161 }
162 struct_ser.end()
163 }
164}
165impl<'de> serde::Deserialize<'de> for AddMutation {
166 #[allow(deprecated)]
167 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
168 where
169 D: serde::Deserializer<'de>,
170 {
171 const FIELDS: &[&str] = &[
172 "actor_dispatchers",
173 "actorDispatchers",
174 "added_actors",
175 "addedActors",
176 "actor_splits",
177 "actorSplits",
178 "pause",
179 "subscriptions_to_add",
180 "subscriptionsToAdd",
181 "backfill_nodes_to_pause",
182 "backfillNodesToPause",
183 ];
184
185 #[allow(clippy::enum_variant_names)]
186 enum GeneratedField {
187 ActorDispatchers,
188 AddedActors,
189 ActorSplits,
190 Pause,
191 SubscriptionsToAdd,
192 BackfillNodesToPause,
193 }
194 impl<'de> serde::Deserialize<'de> for GeneratedField {
195 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
196 where
197 D: serde::Deserializer<'de>,
198 {
199 struct GeneratedVisitor;
200
201 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
202 type Value = GeneratedField;
203
204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
205 write!(formatter, "expected one of: {:?}", &FIELDS)
206 }
207
208 #[allow(unused_variables)]
209 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
210 where
211 E: serde::de::Error,
212 {
213 match value {
214 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
215 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
216 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
217 "pause" => Ok(GeneratedField::Pause),
218 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
219 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
220 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
221 }
222 }
223 }
224 deserializer.deserialize_identifier(GeneratedVisitor)
225 }
226 }
227 struct GeneratedVisitor;
228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
229 type Value = AddMutation;
230
231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
232 formatter.write_str("struct stream_plan.AddMutation")
233 }
234
235 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
236 where
237 V: serde::de::MapAccess<'de>,
238 {
239 let mut actor_dispatchers__ = None;
240 let mut added_actors__ = None;
241 let mut actor_splits__ = None;
242 let mut pause__ = None;
243 let mut subscriptions_to_add__ = None;
244 let mut backfill_nodes_to_pause__ = None;
245 while let Some(k) = map_.next_key()? {
246 match k {
247 GeneratedField::ActorDispatchers => {
248 if actor_dispatchers__.is_some() {
249 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
250 }
251 actor_dispatchers__ = Some(
252 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
253 .into_iter().map(|(k,v)| (k.0, v)).collect()
254 );
255 }
256 GeneratedField::AddedActors => {
257 if added_actors__.is_some() {
258 return Err(serde::de::Error::duplicate_field("addedActors"));
259 }
260 added_actors__ =
261 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
262 .into_iter().map(|x| x.0).collect())
263 ;
264 }
265 GeneratedField::ActorSplits => {
266 if actor_splits__.is_some() {
267 return Err(serde::de::Error::duplicate_field("actorSplits"));
268 }
269 actor_splits__ = Some(
270 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
271 .into_iter().map(|(k,v)| (k.0, v)).collect()
272 );
273 }
274 GeneratedField::Pause => {
275 if pause__.is_some() {
276 return Err(serde::de::Error::duplicate_field("pause"));
277 }
278 pause__ = Some(map_.next_value()?);
279 }
280 GeneratedField::SubscriptionsToAdd => {
281 if subscriptions_to_add__.is_some() {
282 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
283 }
284 subscriptions_to_add__ = Some(map_.next_value()?);
285 }
286 GeneratedField::BackfillNodesToPause => {
287 if backfill_nodes_to_pause__.is_some() {
288 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
289 }
290 backfill_nodes_to_pause__ =
291 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
292 .into_iter().map(|x| x.0).collect())
293 ;
294 }
295 }
296 }
297 Ok(AddMutation {
298 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
299 added_actors: added_actors__.unwrap_or_default(),
300 actor_splits: actor_splits__.unwrap_or_default(),
301 pause: pause__.unwrap_or_default(),
302 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
303 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
304 })
305 }
306 }
307 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
308 }
309}
310impl serde::Serialize for AggCallState {
311 #[allow(deprecated)]
312 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
313 where
314 S: serde::Serializer,
315 {
316 use serde::ser::SerializeStruct;
317 let mut len = 0;
318 if self.inner.is_some() {
319 len += 1;
320 }
321 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
322 if let Some(v) = self.inner.as_ref() {
323 match v {
324 agg_call_state::Inner::ValueState(v) => {
325 struct_ser.serialize_field("valueState", v)?;
326 }
327 agg_call_state::Inner::MaterializedInputState(v) => {
328 struct_ser.serialize_field("materializedInputState", v)?;
329 }
330 }
331 }
332 struct_ser.end()
333 }
334}
335impl<'de> serde::Deserialize<'de> for AggCallState {
336 #[allow(deprecated)]
337 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
338 where
339 D: serde::Deserializer<'de>,
340 {
341 const FIELDS: &[&str] = &[
342 "value_state",
343 "valueState",
344 "materialized_input_state",
345 "materializedInputState",
346 ];
347
348 #[allow(clippy::enum_variant_names)]
349 enum GeneratedField {
350 ValueState,
351 MaterializedInputState,
352 }
353 impl<'de> serde::Deserialize<'de> for GeneratedField {
354 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
355 where
356 D: serde::Deserializer<'de>,
357 {
358 struct GeneratedVisitor;
359
360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
361 type Value = GeneratedField;
362
363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
364 write!(formatter, "expected one of: {:?}", &FIELDS)
365 }
366
367 #[allow(unused_variables)]
368 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
369 where
370 E: serde::de::Error,
371 {
372 match value {
373 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
374 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
375 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
376 }
377 }
378 }
379 deserializer.deserialize_identifier(GeneratedVisitor)
380 }
381 }
382 struct GeneratedVisitor;
383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
384 type Value = AggCallState;
385
386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
387 formatter.write_str("struct stream_plan.AggCallState")
388 }
389
390 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
391 where
392 V: serde::de::MapAccess<'de>,
393 {
394 let mut inner__ = None;
395 while let Some(k) = map_.next_key()? {
396 match k {
397 GeneratedField::ValueState => {
398 if inner__.is_some() {
399 return Err(serde::de::Error::duplicate_field("valueState"));
400 }
401 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
402;
403 }
404 GeneratedField::MaterializedInputState => {
405 if inner__.is_some() {
406 return Err(serde::de::Error::duplicate_field("materializedInputState"));
407 }
408 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
409;
410 }
411 }
412 }
413 Ok(AggCallState {
414 inner: inner__,
415 })
416 }
417 }
418 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
419 }
420}
421impl serde::Serialize for agg_call_state::MaterializedInputState {
422 #[allow(deprecated)]
423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
424 where
425 S: serde::Serializer,
426 {
427 use serde::ser::SerializeStruct;
428 let mut len = 0;
429 if self.table.is_some() {
430 len += 1;
431 }
432 if !self.included_upstream_indices.is_empty() {
433 len += 1;
434 }
435 if !self.table_value_indices.is_empty() {
436 len += 1;
437 }
438 if !self.order_columns.is_empty() {
439 len += 1;
440 }
441 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
442 if let Some(v) = self.table.as_ref() {
443 struct_ser.serialize_field("table", v)?;
444 }
445 if !self.included_upstream_indices.is_empty() {
446 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
447 }
448 if !self.table_value_indices.is_empty() {
449 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
450 }
451 if !self.order_columns.is_empty() {
452 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
453 }
454 struct_ser.end()
455 }
456}
457impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
458 #[allow(deprecated)]
459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
460 where
461 D: serde::Deserializer<'de>,
462 {
463 const FIELDS: &[&str] = &[
464 "table",
465 "included_upstream_indices",
466 "includedUpstreamIndices",
467 "table_value_indices",
468 "tableValueIndices",
469 "order_columns",
470 "orderColumns",
471 ];
472
473 #[allow(clippy::enum_variant_names)]
474 enum GeneratedField {
475 Table,
476 IncludedUpstreamIndices,
477 TableValueIndices,
478 OrderColumns,
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<'de> serde::de::Visitor<'de> 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 "table" => Ok(GeneratedField::Table),
501 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
502 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
503 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
505 }
506 }
507 }
508 deserializer.deserialize_identifier(GeneratedVisitor)
509 }
510 }
511 struct GeneratedVisitor;
512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
513 type Value = agg_call_state::MaterializedInputState;
514
515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
516 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
517 }
518
519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
520 where
521 V: serde::de::MapAccess<'de>,
522 {
523 let mut table__ = None;
524 let mut included_upstream_indices__ = None;
525 let mut table_value_indices__ = None;
526 let mut order_columns__ = None;
527 while let Some(k) = map_.next_key()? {
528 match k {
529 GeneratedField::Table => {
530 if table__.is_some() {
531 return Err(serde::de::Error::duplicate_field("table"));
532 }
533 table__ = map_.next_value()?;
534 }
535 GeneratedField::IncludedUpstreamIndices => {
536 if included_upstream_indices__.is_some() {
537 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
538 }
539 included_upstream_indices__ =
540 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
541 .into_iter().map(|x| x.0).collect())
542 ;
543 }
544 GeneratedField::TableValueIndices => {
545 if table_value_indices__.is_some() {
546 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
547 }
548 table_value_indices__ =
549 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
550 .into_iter().map(|x| x.0).collect())
551 ;
552 }
553 GeneratedField::OrderColumns => {
554 if order_columns__.is_some() {
555 return Err(serde::de::Error::duplicate_field("orderColumns"));
556 }
557 order_columns__ = Some(map_.next_value()?);
558 }
559 }
560 }
561 Ok(agg_call_state::MaterializedInputState {
562 table: table__,
563 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
564 table_value_indices: table_value_indices__.unwrap_or_default(),
565 order_columns: order_columns__.unwrap_or_default(),
566 })
567 }
568 }
569 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
570 }
571}
572impl serde::Serialize for agg_call_state::ValueState {
573 #[allow(deprecated)]
574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
575 where
576 S: serde::Serializer,
577 {
578 use serde::ser::SerializeStruct;
579 let len = 0;
580 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
581 struct_ser.end()
582 }
583}
584impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
585 #[allow(deprecated)]
586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
587 where
588 D: serde::Deserializer<'de>,
589 {
590 const FIELDS: &[&str] = &[
591 ];
592
593 #[allow(clippy::enum_variant_names)]
594 enum GeneratedField {
595 }
596 impl<'de> serde::Deserialize<'de> for GeneratedField {
597 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
598 where
599 D: serde::Deserializer<'de>,
600 {
601 struct GeneratedVisitor;
602
603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
604 type Value = GeneratedField;
605
606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
607 write!(formatter, "expected one of: {:?}", &FIELDS)
608 }
609
610 #[allow(unused_variables)]
611 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
612 where
613 E: serde::de::Error,
614 {
615 Err(serde::de::Error::unknown_field(value, FIELDS))
616 }
617 }
618 deserializer.deserialize_identifier(GeneratedVisitor)
619 }
620 }
621 struct GeneratedVisitor;
622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
623 type Value = agg_call_state::ValueState;
624
625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
626 formatter.write_str("struct stream_plan.AggCallState.ValueState")
627 }
628
629 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
630 where
631 V: serde::de::MapAccess<'de>,
632 {
633 while map_.next_key::<GeneratedField>()?.is_some() {
634 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
635 }
636 Ok(agg_call_state::ValueState {
637 })
638 }
639 }
640 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
641 }
642}
643impl serde::Serialize for AggNodeVersion {
644 #[allow(deprecated)]
645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
646 where
647 S: serde::Serializer,
648 {
649 let variant = match self {
650 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
651 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
652 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
653 };
654 serializer.serialize_str(variant)
655 }
656}
657impl<'de> serde::Deserialize<'de> for AggNodeVersion {
658 #[allow(deprecated)]
659 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
660 where
661 D: serde::Deserializer<'de>,
662 {
663 const FIELDS: &[&str] = &[
664 "AGG_NODE_VERSION_UNSPECIFIED",
665 "AGG_NODE_VERSION_ISSUE_12140",
666 "AGG_NODE_VERSION_ISSUE_13465",
667 ];
668
669 struct GeneratedVisitor;
670
671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
672 type Value = AggNodeVersion;
673
674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
675 write!(formatter, "expected one of: {:?}", &FIELDS)
676 }
677
678 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
679 where
680 E: serde::de::Error,
681 {
682 i32::try_from(v)
683 .ok()
684 .and_then(|x| x.try_into().ok())
685 .ok_or_else(|| {
686 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
687 })
688 }
689
690 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
691 where
692 E: serde::de::Error,
693 {
694 i32::try_from(v)
695 .ok()
696 .and_then(|x| x.try_into().ok())
697 .ok_or_else(|| {
698 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
699 })
700 }
701
702 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
703 where
704 E: serde::de::Error,
705 {
706 match value {
707 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
708 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
709 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
710 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
711 }
712 }
713 }
714 deserializer.deserialize_any(GeneratedVisitor)
715 }
716}
717impl serde::Serialize for ArrangeNode {
718 #[allow(deprecated)]
719 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
720 where
721 S: serde::Serializer,
722 {
723 use serde::ser::SerializeStruct;
724 let mut len = 0;
725 if self.table_info.is_some() {
726 len += 1;
727 }
728 if !self.distribution_key.is_empty() {
729 len += 1;
730 }
731 if self.table.is_some() {
732 len += 1;
733 }
734 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
735 if let Some(v) = self.table_info.as_ref() {
736 struct_ser.serialize_field("tableInfo", v)?;
737 }
738 if !self.distribution_key.is_empty() {
739 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
740 }
741 if let Some(v) = self.table.as_ref() {
742 struct_ser.serialize_field("table", v)?;
743 }
744 struct_ser.end()
745 }
746}
747impl<'de> serde::Deserialize<'de> for ArrangeNode {
748 #[allow(deprecated)]
749 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
750 where
751 D: serde::Deserializer<'de>,
752 {
753 const FIELDS: &[&str] = &[
754 "table_info",
755 "tableInfo",
756 "distribution_key",
757 "distributionKey",
758 "table",
759 ];
760
761 #[allow(clippy::enum_variant_names)]
762 enum GeneratedField {
763 TableInfo,
764 DistributionKey,
765 Table,
766 }
767 impl<'de> serde::Deserialize<'de> for GeneratedField {
768 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
769 where
770 D: serde::Deserializer<'de>,
771 {
772 struct GeneratedVisitor;
773
774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
775 type Value = GeneratedField;
776
777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
778 write!(formatter, "expected one of: {:?}", &FIELDS)
779 }
780
781 #[allow(unused_variables)]
782 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
783 where
784 E: serde::de::Error,
785 {
786 match value {
787 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
788 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
789 "table" => Ok(GeneratedField::Table),
790 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
791 }
792 }
793 }
794 deserializer.deserialize_identifier(GeneratedVisitor)
795 }
796 }
797 struct GeneratedVisitor;
798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
799 type Value = ArrangeNode;
800
801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
802 formatter.write_str("struct stream_plan.ArrangeNode")
803 }
804
805 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
806 where
807 V: serde::de::MapAccess<'de>,
808 {
809 let mut table_info__ = None;
810 let mut distribution_key__ = None;
811 let mut table__ = None;
812 while let Some(k) = map_.next_key()? {
813 match k {
814 GeneratedField::TableInfo => {
815 if table_info__.is_some() {
816 return Err(serde::de::Error::duplicate_field("tableInfo"));
817 }
818 table_info__ = map_.next_value()?;
819 }
820 GeneratedField::DistributionKey => {
821 if distribution_key__.is_some() {
822 return Err(serde::de::Error::duplicate_field("distributionKey"));
823 }
824 distribution_key__ =
825 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
826 .into_iter().map(|x| x.0).collect())
827 ;
828 }
829 GeneratedField::Table => {
830 if table__.is_some() {
831 return Err(serde::de::Error::duplicate_field("table"));
832 }
833 table__ = map_.next_value()?;
834 }
835 }
836 }
837 Ok(ArrangeNode {
838 table_info: table_info__,
839 distribution_key: distribution_key__.unwrap_or_default(),
840 table: table__,
841 })
842 }
843 }
844 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
845 }
846}
847impl serde::Serialize for ArrangementInfo {
848 #[allow(deprecated)]
849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
850 where
851 S: serde::Serializer,
852 {
853 use serde::ser::SerializeStruct;
854 let mut len = 0;
855 if !self.arrange_key_orders.is_empty() {
856 len += 1;
857 }
858 if !self.column_descs.is_empty() {
859 len += 1;
860 }
861 if self.table_desc.is_some() {
862 len += 1;
863 }
864 if !self.output_col_idx.is_empty() {
865 len += 1;
866 }
867 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
868 if !self.arrange_key_orders.is_empty() {
869 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
870 }
871 if !self.column_descs.is_empty() {
872 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
873 }
874 if let Some(v) = self.table_desc.as_ref() {
875 struct_ser.serialize_field("tableDesc", v)?;
876 }
877 if !self.output_col_idx.is_empty() {
878 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
879 }
880 struct_ser.end()
881 }
882}
883impl<'de> serde::Deserialize<'de> for ArrangementInfo {
884 #[allow(deprecated)]
885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
886 where
887 D: serde::Deserializer<'de>,
888 {
889 const FIELDS: &[&str] = &[
890 "arrange_key_orders",
891 "arrangeKeyOrders",
892 "column_descs",
893 "columnDescs",
894 "table_desc",
895 "tableDesc",
896 "output_col_idx",
897 "outputColIdx",
898 ];
899
900 #[allow(clippy::enum_variant_names)]
901 enum GeneratedField {
902 ArrangeKeyOrders,
903 ColumnDescs,
904 TableDesc,
905 OutputColIdx,
906 }
907 impl<'de> serde::Deserialize<'de> for GeneratedField {
908 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
909 where
910 D: serde::Deserializer<'de>,
911 {
912 struct GeneratedVisitor;
913
914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
915 type Value = GeneratedField;
916
917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
918 write!(formatter, "expected one of: {:?}", &FIELDS)
919 }
920
921 #[allow(unused_variables)]
922 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
923 where
924 E: serde::de::Error,
925 {
926 match value {
927 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
928 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
929 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
930 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
932 }
933 }
934 }
935 deserializer.deserialize_identifier(GeneratedVisitor)
936 }
937 }
938 struct GeneratedVisitor;
939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
940 type Value = ArrangementInfo;
941
942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
943 formatter.write_str("struct stream_plan.ArrangementInfo")
944 }
945
946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
947 where
948 V: serde::de::MapAccess<'de>,
949 {
950 let mut arrange_key_orders__ = None;
951 let mut column_descs__ = None;
952 let mut table_desc__ = None;
953 let mut output_col_idx__ = None;
954 while let Some(k) = map_.next_key()? {
955 match k {
956 GeneratedField::ArrangeKeyOrders => {
957 if arrange_key_orders__.is_some() {
958 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
959 }
960 arrange_key_orders__ = Some(map_.next_value()?);
961 }
962 GeneratedField::ColumnDescs => {
963 if column_descs__.is_some() {
964 return Err(serde::de::Error::duplicate_field("columnDescs"));
965 }
966 column_descs__ = Some(map_.next_value()?);
967 }
968 GeneratedField::TableDesc => {
969 if table_desc__.is_some() {
970 return Err(serde::de::Error::duplicate_field("tableDesc"));
971 }
972 table_desc__ = map_.next_value()?;
973 }
974 GeneratedField::OutputColIdx => {
975 if output_col_idx__.is_some() {
976 return Err(serde::de::Error::duplicate_field("outputColIdx"));
977 }
978 output_col_idx__ =
979 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
980 .into_iter().map(|x| x.0).collect())
981 ;
982 }
983 }
984 }
985 Ok(ArrangementInfo {
986 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
987 column_descs: column_descs__.unwrap_or_default(),
988 table_desc: table_desc__,
989 output_col_idx: output_col_idx__.unwrap_or_default(),
990 })
991 }
992 }
993 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
994 }
995}
996impl serde::Serialize for AsOfJoinNode {
997 #[allow(deprecated)]
998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
999 where
1000 S: serde::Serializer,
1001 {
1002 use serde::ser::SerializeStruct;
1003 let mut len = 0;
1004 if self.join_type != 0 {
1005 len += 1;
1006 }
1007 if !self.left_key.is_empty() {
1008 len += 1;
1009 }
1010 if !self.right_key.is_empty() {
1011 len += 1;
1012 }
1013 if self.left_table.is_some() {
1014 len += 1;
1015 }
1016 if self.right_table.is_some() {
1017 len += 1;
1018 }
1019 if !self.output_indices.is_empty() {
1020 len += 1;
1021 }
1022 if !self.left_deduped_input_pk_indices.is_empty() {
1023 len += 1;
1024 }
1025 if !self.right_deduped_input_pk_indices.is_empty() {
1026 len += 1;
1027 }
1028 if !self.null_safe.is_empty() {
1029 len += 1;
1030 }
1031 if self.asof_desc.is_some() {
1032 len += 1;
1033 }
1034 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1035 if self.join_type != 0 {
1036 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1037 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1038 struct_ser.serialize_field("joinType", &v)?;
1039 }
1040 if !self.left_key.is_empty() {
1041 struct_ser.serialize_field("leftKey", &self.left_key)?;
1042 }
1043 if !self.right_key.is_empty() {
1044 struct_ser.serialize_field("rightKey", &self.right_key)?;
1045 }
1046 if let Some(v) = self.left_table.as_ref() {
1047 struct_ser.serialize_field("leftTable", v)?;
1048 }
1049 if let Some(v) = self.right_table.as_ref() {
1050 struct_ser.serialize_field("rightTable", v)?;
1051 }
1052 if !self.output_indices.is_empty() {
1053 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1054 }
1055 if !self.left_deduped_input_pk_indices.is_empty() {
1056 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1057 }
1058 if !self.right_deduped_input_pk_indices.is_empty() {
1059 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1060 }
1061 if !self.null_safe.is_empty() {
1062 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1063 }
1064 if let Some(v) = self.asof_desc.as_ref() {
1065 struct_ser.serialize_field("asofDesc", v)?;
1066 }
1067 struct_ser.end()
1068 }
1069}
1070impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1071 #[allow(deprecated)]
1072 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1073 where
1074 D: serde::Deserializer<'de>,
1075 {
1076 const FIELDS: &[&str] = &[
1077 "join_type",
1078 "joinType",
1079 "left_key",
1080 "leftKey",
1081 "right_key",
1082 "rightKey",
1083 "left_table",
1084 "leftTable",
1085 "right_table",
1086 "rightTable",
1087 "output_indices",
1088 "outputIndices",
1089 "left_deduped_input_pk_indices",
1090 "leftDedupedInputPkIndices",
1091 "right_deduped_input_pk_indices",
1092 "rightDedupedInputPkIndices",
1093 "null_safe",
1094 "nullSafe",
1095 "asof_desc",
1096 "asofDesc",
1097 ];
1098
1099 #[allow(clippy::enum_variant_names)]
1100 enum GeneratedField {
1101 JoinType,
1102 LeftKey,
1103 RightKey,
1104 LeftTable,
1105 RightTable,
1106 OutputIndices,
1107 LeftDedupedInputPkIndices,
1108 RightDedupedInputPkIndices,
1109 NullSafe,
1110 AsofDesc,
1111 }
1112 impl<'de> serde::Deserialize<'de> for GeneratedField {
1113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1114 where
1115 D: serde::Deserializer<'de>,
1116 {
1117 struct GeneratedVisitor;
1118
1119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1120 type Value = GeneratedField;
1121
1122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1123 write!(formatter, "expected one of: {:?}", &FIELDS)
1124 }
1125
1126 #[allow(unused_variables)]
1127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1128 where
1129 E: serde::de::Error,
1130 {
1131 match value {
1132 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1133 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1134 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1135 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1136 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1137 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1138 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1139 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1140 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1141 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1142 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1143 }
1144 }
1145 }
1146 deserializer.deserialize_identifier(GeneratedVisitor)
1147 }
1148 }
1149 struct GeneratedVisitor;
1150 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1151 type Value = AsOfJoinNode;
1152
1153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1154 formatter.write_str("struct stream_plan.AsOfJoinNode")
1155 }
1156
1157 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1158 where
1159 V: serde::de::MapAccess<'de>,
1160 {
1161 let mut join_type__ = None;
1162 let mut left_key__ = None;
1163 let mut right_key__ = None;
1164 let mut left_table__ = None;
1165 let mut right_table__ = None;
1166 let mut output_indices__ = None;
1167 let mut left_deduped_input_pk_indices__ = None;
1168 let mut right_deduped_input_pk_indices__ = None;
1169 let mut null_safe__ = None;
1170 let mut asof_desc__ = None;
1171 while let Some(k) = map_.next_key()? {
1172 match k {
1173 GeneratedField::JoinType => {
1174 if join_type__.is_some() {
1175 return Err(serde::de::Error::duplicate_field("joinType"));
1176 }
1177 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1178 }
1179 GeneratedField::LeftKey => {
1180 if left_key__.is_some() {
1181 return Err(serde::de::Error::duplicate_field("leftKey"));
1182 }
1183 left_key__ =
1184 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1185 .into_iter().map(|x| x.0).collect())
1186 ;
1187 }
1188 GeneratedField::RightKey => {
1189 if right_key__.is_some() {
1190 return Err(serde::de::Error::duplicate_field("rightKey"));
1191 }
1192 right_key__ =
1193 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1194 .into_iter().map(|x| x.0).collect())
1195 ;
1196 }
1197 GeneratedField::LeftTable => {
1198 if left_table__.is_some() {
1199 return Err(serde::de::Error::duplicate_field("leftTable"));
1200 }
1201 left_table__ = map_.next_value()?;
1202 }
1203 GeneratedField::RightTable => {
1204 if right_table__.is_some() {
1205 return Err(serde::de::Error::duplicate_field("rightTable"));
1206 }
1207 right_table__ = map_.next_value()?;
1208 }
1209 GeneratedField::OutputIndices => {
1210 if output_indices__.is_some() {
1211 return Err(serde::de::Error::duplicate_field("outputIndices"));
1212 }
1213 output_indices__ =
1214 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1215 .into_iter().map(|x| x.0).collect())
1216 ;
1217 }
1218 GeneratedField::LeftDedupedInputPkIndices => {
1219 if left_deduped_input_pk_indices__.is_some() {
1220 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1221 }
1222 left_deduped_input_pk_indices__ =
1223 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1224 .into_iter().map(|x| x.0).collect())
1225 ;
1226 }
1227 GeneratedField::RightDedupedInputPkIndices => {
1228 if right_deduped_input_pk_indices__.is_some() {
1229 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1230 }
1231 right_deduped_input_pk_indices__ =
1232 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1233 .into_iter().map(|x| x.0).collect())
1234 ;
1235 }
1236 GeneratedField::NullSafe => {
1237 if null_safe__.is_some() {
1238 return Err(serde::de::Error::duplicate_field("nullSafe"));
1239 }
1240 null_safe__ = Some(map_.next_value()?);
1241 }
1242 GeneratedField::AsofDesc => {
1243 if asof_desc__.is_some() {
1244 return Err(serde::de::Error::duplicate_field("asofDesc"));
1245 }
1246 asof_desc__ = map_.next_value()?;
1247 }
1248 }
1249 }
1250 Ok(AsOfJoinNode {
1251 join_type: join_type__.unwrap_or_default(),
1252 left_key: left_key__.unwrap_or_default(),
1253 right_key: right_key__.unwrap_or_default(),
1254 left_table: left_table__,
1255 right_table: right_table__,
1256 output_indices: output_indices__.unwrap_or_default(),
1257 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1258 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1259 null_safe: null_safe__.unwrap_or_default(),
1260 asof_desc: asof_desc__,
1261 })
1262 }
1263 }
1264 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1265 }
1266}
1267impl serde::Serialize for BackfillOrder {
1268 #[allow(deprecated)]
1269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1270 where
1271 S: serde::Serializer,
1272 {
1273 use serde::ser::SerializeStruct;
1274 let mut len = 0;
1275 if !self.order.is_empty() {
1276 len += 1;
1277 }
1278 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1279 if !self.order.is_empty() {
1280 struct_ser.serialize_field("order", &self.order)?;
1281 }
1282 struct_ser.end()
1283 }
1284}
1285impl<'de> serde::Deserialize<'de> for BackfillOrder {
1286 #[allow(deprecated)]
1287 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1288 where
1289 D: serde::Deserializer<'de>,
1290 {
1291 const FIELDS: &[&str] = &[
1292 "order",
1293 ];
1294
1295 #[allow(clippy::enum_variant_names)]
1296 enum GeneratedField {
1297 Order,
1298 }
1299 impl<'de> serde::Deserialize<'de> for GeneratedField {
1300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1301 where
1302 D: serde::Deserializer<'de>,
1303 {
1304 struct GeneratedVisitor;
1305
1306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1307 type Value = GeneratedField;
1308
1309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1310 write!(formatter, "expected one of: {:?}", &FIELDS)
1311 }
1312
1313 #[allow(unused_variables)]
1314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1315 where
1316 E: serde::de::Error,
1317 {
1318 match value {
1319 "order" => Ok(GeneratedField::Order),
1320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1321 }
1322 }
1323 }
1324 deserializer.deserialize_identifier(GeneratedVisitor)
1325 }
1326 }
1327 struct GeneratedVisitor;
1328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1329 type Value = BackfillOrder;
1330
1331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1332 formatter.write_str("struct stream_plan.BackfillOrder")
1333 }
1334
1335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1336 where
1337 V: serde::de::MapAccess<'de>,
1338 {
1339 let mut order__ = None;
1340 while let Some(k) = map_.next_key()? {
1341 match k {
1342 GeneratedField::Order => {
1343 if order__.is_some() {
1344 return Err(serde::de::Error::duplicate_field("order"));
1345 }
1346 order__ = Some(
1347 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1348 .into_iter().map(|(k,v)| (k.0, v)).collect()
1349 );
1350 }
1351 }
1352 }
1353 Ok(BackfillOrder {
1354 order: order__.unwrap_or_default(),
1355 })
1356 }
1357 }
1358 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1359 }
1360}
1361impl serde::Serialize for Barrier {
1362 #[allow(deprecated)]
1363 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1364 where
1365 S: serde::Serializer,
1366 {
1367 use serde::ser::SerializeStruct;
1368 let mut len = 0;
1369 if self.epoch.is_some() {
1370 len += 1;
1371 }
1372 if self.mutation.is_some() {
1373 len += 1;
1374 }
1375 if !self.tracing_context.is_empty() {
1376 len += 1;
1377 }
1378 if self.kind != 0 {
1379 len += 1;
1380 }
1381 if !self.passed_actors.is_empty() {
1382 len += 1;
1383 }
1384 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1385 if let Some(v) = self.epoch.as_ref() {
1386 struct_ser.serialize_field("epoch", v)?;
1387 }
1388 if let Some(v) = self.mutation.as_ref() {
1389 struct_ser.serialize_field("mutation", v)?;
1390 }
1391 if !self.tracing_context.is_empty() {
1392 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1393 }
1394 if self.kind != 0 {
1395 let v = barrier::BarrierKind::try_from(self.kind)
1396 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1397 struct_ser.serialize_field("kind", &v)?;
1398 }
1399 if !self.passed_actors.is_empty() {
1400 struct_ser.serialize_field("passedActors", &self.passed_actors)?;
1401 }
1402 struct_ser.end()
1403 }
1404}
1405impl<'de> serde::Deserialize<'de> for Barrier {
1406 #[allow(deprecated)]
1407 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1408 where
1409 D: serde::Deserializer<'de>,
1410 {
1411 const FIELDS: &[&str] = &[
1412 "epoch",
1413 "mutation",
1414 "tracing_context",
1415 "tracingContext",
1416 "kind",
1417 "passed_actors",
1418 "passedActors",
1419 ];
1420
1421 #[allow(clippy::enum_variant_names)]
1422 enum GeneratedField {
1423 Epoch,
1424 Mutation,
1425 TracingContext,
1426 Kind,
1427 PassedActors,
1428 }
1429 impl<'de> serde::Deserialize<'de> for GeneratedField {
1430 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1431 where
1432 D: serde::Deserializer<'de>,
1433 {
1434 struct GeneratedVisitor;
1435
1436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1437 type Value = GeneratedField;
1438
1439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1440 write!(formatter, "expected one of: {:?}", &FIELDS)
1441 }
1442
1443 #[allow(unused_variables)]
1444 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1445 where
1446 E: serde::de::Error,
1447 {
1448 match value {
1449 "epoch" => Ok(GeneratedField::Epoch),
1450 "mutation" => Ok(GeneratedField::Mutation),
1451 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1452 "kind" => Ok(GeneratedField::Kind),
1453 "passedActors" | "passed_actors" => Ok(GeneratedField::PassedActors),
1454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1455 }
1456 }
1457 }
1458 deserializer.deserialize_identifier(GeneratedVisitor)
1459 }
1460 }
1461 struct GeneratedVisitor;
1462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1463 type Value = Barrier;
1464
1465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1466 formatter.write_str("struct stream_plan.Barrier")
1467 }
1468
1469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1470 where
1471 V: serde::de::MapAccess<'de>,
1472 {
1473 let mut epoch__ = None;
1474 let mut mutation__ = None;
1475 let mut tracing_context__ = None;
1476 let mut kind__ = None;
1477 let mut passed_actors__ = None;
1478 while let Some(k) = map_.next_key()? {
1479 match k {
1480 GeneratedField::Epoch => {
1481 if epoch__.is_some() {
1482 return Err(serde::de::Error::duplicate_field("epoch"));
1483 }
1484 epoch__ = map_.next_value()?;
1485 }
1486 GeneratedField::Mutation => {
1487 if mutation__.is_some() {
1488 return Err(serde::de::Error::duplicate_field("mutation"));
1489 }
1490 mutation__ = map_.next_value()?;
1491 }
1492 GeneratedField::TracingContext => {
1493 if tracing_context__.is_some() {
1494 return Err(serde::de::Error::duplicate_field("tracingContext"));
1495 }
1496 tracing_context__ = Some(
1497 map_.next_value::<std::collections::HashMap<_, _>>()?
1498 );
1499 }
1500 GeneratedField::Kind => {
1501 if kind__.is_some() {
1502 return Err(serde::de::Error::duplicate_field("kind"));
1503 }
1504 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1505 }
1506 GeneratedField::PassedActors => {
1507 if passed_actors__.is_some() {
1508 return Err(serde::de::Error::duplicate_field("passedActors"));
1509 }
1510 passed_actors__ =
1511 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1512 .into_iter().map(|x| x.0).collect())
1513 ;
1514 }
1515 }
1516 }
1517 Ok(Barrier {
1518 epoch: epoch__,
1519 mutation: mutation__,
1520 tracing_context: tracing_context__.unwrap_or_default(),
1521 kind: kind__.unwrap_or_default(),
1522 passed_actors: passed_actors__.unwrap_or_default(),
1523 })
1524 }
1525 }
1526 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1527 }
1528}
1529impl serde::Serialize for barrier::BarrierKind {
1530 #[allow(deprecated)]
1531 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1532 where
1533 S: serde::Serializer,
1534 {
1535 let variant = match self {
1536 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1537 Self::Initial => "BARRIER_KIND_INITIAL",
1538 Self::Barrier => "BARRIER_KIND_BARRIER",
1539 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1540 };
1541 serializer.serialize_str(variant)
1542 }
1543}
1544impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1545 #[allow(deprecated)]
1546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1547 where
1548 D: serde::Deserializer<'de>,
1549 {
1550 const FIELDS: &[&str] = &[
1551 "BARRIER_KIND_UNSPECIFIED",
1552 "BARRIER_KIND_INITIAL",
1553 "BARRIER_KIND_BARRIER",
1554 "BARRIER_KIND_CHECKPOINT",
1555 ];
1556
1557 struct GeneratedVisitor;
1558
1559 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1560 type Value = barrier::BarrierKind;
1561
1562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1563 write!(formatter, "expected one of: {:?}", &FIELDS)
1564 }
1565
1566 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1567 where
1568 E: serde::de::Error,
1569 {
1570 i32::try_from(v)
1571 .ok()
1572 .and_then(|x| x.try_into().ok())
1573 .ok_or_else(|| {
1574 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1575 })
1576 }
1577
1578 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1579 where
1580 E: serde::de::Error,
1581 {
1582 i32::try_from(v)
1583 .ok()
1584 .and_then(|x| x.try_into().ok())
1585 .ok_or_else(|| {
1586 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1587 })
1588 }
1589
1590 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1591 where
1592 E: serde::de::Error,
1593 {
1594 match value {
1595 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1596 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1597 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1598 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1599 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1600 }
1601 }
1602 }
1603 deserializer.deserialize_any(GeneratedVisitor)
1604 }
1605}
1606impl serde::Serialize for BarrierMutation {
1607 #[allow(deprecated)]
1608 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1609 where
1610 S: serde::Serializer,
1611 {
1612 use serde::ser::SerializeStruct;
1613 let mut len = 0;
1614 if self.mutation.is_some() {
1615 len += 1;
1616 }
1617 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1618 if let Some(v) = self.mutation.as_ref() {
1619 match v {
1620 barrier_mutation::Mutation::Add(v) => {
1621 struct_ser.serialize_field("add", v)?;
1622 }
1623 barrier_mutation::Mutation::Stop(v) => {
1624 struct_ser.serialize_field("stop", v)?;
1625 }
1626 barrier_mutation::Mutation::Update(v) => {
1627 struct_ser.serialize_field("update", v)?;
1628 }
1629 barrier_mutation::Mutation::Splits(v) => {
1630 struct_ser.serialize_field("splits", v)?;
1631 }
1632 barrier_mutation::Mutation::Pause(v) => {
1633 struct_ser.serialize_field("pause", v)?;
1634 }
1635 barrier_mutation::Mutation::Resume(v) => {
1636 struct_ser.serialize_field("resume", v)?;
1637 }
1638 barrier_mutation::Mutation::Throttle(v) => {
1639 struct_ser.serialize_field("throttle", v)?;
1640 }
1641 barrier_mutation::Mutation::DropSubscriptions(v) => {
1642 struct_ser.serialize_field("dropSubscriptions", v)?;
1643 }
1644 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1645 struct_ser.serialize_field("connectorPropsChange", v)?;
1646 }
1647 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1648 struct_ser.serialize_field("startFragmentBackfill", v)?;
1649 }
1650 barrier_mutation::Mutation::Combined(v) => {
1651 struct_ser.serialize_field("combined", v)?;
1652 }
1653 }
1654 }
1655 struct_ser.end()
1656 }
1657}
1658impl<'de> serde::Deserialize<'de> for BarrierMutation {
1659 #[allow(deprecated)]
1660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1661 where
1662 D: serde::Deserializer<'de>,
1663 {
1664 const FIELDS: &[&str] = &[
1665 "add",
1666 "stop",
1667 "update",
1668 "splits",
1669 "pause",
1670 "resume",
1671 "throttle",
1672 "drop_subscriptions",
1673 "dropSubscriptions",
1674 "connector_props_change",
1675 "connectorPropsChange",
1676 "start_fragment_backfill",
1677 "startFragmentBackfill",
1678 "combined",
1679 ];
1680
1681 #[allow(clippy::enum_variant_names)]
1682 enum GeneratedField {
1683 Add,
1684 Stop,
1685 Update,
1686 Splits,
1687 Pause,
1688 Resume,
1689 Throttle,
1690 DropSubscriptions,
1691 ConnectorPropsChange,
1692 StartFragmentBackfill,
1693 Combined,
1694 }
1695 impl<'de> serde::Deserialize<'de> for GeneratedField {
1696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1697 where
1698 D: serde::Deserializer<'de>,
1699 {
1700 struct GeneratedVisitor;
1701
1702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1703 type Value = GeneratedField;
1704
1705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1706 write!(formatter, "expected one of: {:?}", &FIELDS)
1707 }
1708
1709 #[allow(unused_variables)]
1710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1711 where
1712 E: serde::de::Error,
1713 {
1714 match value {
1715 "add" => Ok(GeneratedField::Add),
1716 "stop" => Ok(GeneratedField::Stop),
1717 "update" => Ok(GeneratedField::Update),
1718 "splits" => Ok(GeneratedField::Splits),
1719 "pause" => Ok(GeneratedField::Pause),
1720 "resume" => Ok(GeneratedField::Resume),
1721 "throttle" => Ok(GeneratedField::Throttle),
1722 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1723 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1724 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1725 "combined" => Ok(GeneratedField::Combined),
1726 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1727 }
1728 }
1729 }
1730 deserializer.deserialize_identifier(GeneratedVisitor)
1731 }
1732 }
1733 struct GeneratedVisitor;
1734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1735 type Value = BarrierMutation;
1736
1737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1738 formatter.write_str("struct stream_plan.BarrierMutation")
1739 }
1740
1741 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1742 where
1743 V: serde::de::MapAccess<'de>,
1744 {
1745 let mut mutation__ = None;
1746 while let Some(k) = map_.next_key()? {
1747 match k {
1748 GeneratedField::Add => {
1749 if mutation__.is_some() {
1750 return Err(serde::de::Error::duplicate_field("add"));
1751 }
1752 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1753;
1754 }
1755 GeneratedField::Stop => {
1756 if mutation__.is_some() {
1757 return Err(serde::de::Error::duplicate_field("stop"));
1758 }
1759 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1760;
1761 }
1762 GeneratedField::Update => {
1763 if mutation__.is_some() {
1764 return Err(serde::de::Error::duplicate_field("update"));
1765 }
1766 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1767;
1768 }
1769 GeneratedField::Splits => {
1770 if mutation__.is_some() {
1771 return Err(serde::de::Error::duplicate_field("splits"));
1772 }
1773 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1774;
1775 }
1776 GeneratedField::Pause => {
1777 if mutation__.is_some() {
1778 return Err(serde::de::Error::duplicate_field("pause"));
1779 }
1780 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1781;
1782 }
1783 GeneratedField::Resume => {
1784 if mutation__.is_some() {
1785 return Err(serde::de::Error::duplicate_field("resume"));
1786 }
1787 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1788;
1789 }
1790 GeneratedField::Throttle => {
1791 if mutation__.is_some() {
1792 return Err(serde::de::Error::duplicate_field("throttle"));
1793 }
1794 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1795;
1796 }
1797 GeneratedField::DropSubscriptions => {
1798 if mutation__.is_some() {
1799 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1800 }
1801 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1802;
1803 }
1804 GeneratedField::ConnectorPropsChange => {
1805 if mutation__.is_some() {
1806 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1807 }
1808 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1809;
1810 }
1811 GeneratedField::StartFragmentBackfill => {
1812 if mutation__.is_some() {
1813 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1814 }
1815 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1816;
1817 }
1818 GeneratedField::Combined => {
1819 if mutation__.is_some() {
1820 return Err(serde::de::Error::duplicate_field("combined"));
1821 }
1822 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Combined)
1823;
1824 }
1825 }
1826 }
1827 Ok(BarrierMutation {
1828 mutation: mutation__,
1829 })
1830 }
1831 }
1832 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
1833 }
1834}
1835impl serde::Serialize for BarrierRecvNode {
1836 #[allow(deprecated)]
1837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1838 where
1839 S: serde::Serializer,
1840 {
1841 use serde::ser::SerializeStruct;
1842 let len = 0;
1843 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
1844 struct_ser.end()
1845 }
1846}
1847impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
1848 #[allow(deprecated)]
1849 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1850 where
1851 D: serde::Deserializer<'de>,
1852 {
1853 const FIELDS: &[&str] = &[
1854 ];
1855
1856 #[allow(clippy::enum_variant_names)]
1857 enum GeneratedField {
1858 }
1859 impl<'de> serde::Deserialize<'de> for GeneratedField {
1860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1861 where
1862 D: serde::Deserializer<'de>,
1863 {
1864 struct GeneratedVisitor;
1865
1866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1867 type Value = GeneratedField;
1868
1869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1870 write!(formatter, "expected one of: {:?}", &FIELDS)
1871 }
1872
1873 #[allow(unused_variables)]
1874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1875 where
1876 E: serde::de::Error,
1877 {
1878 Err(serde::de::Error::unknown_field(value, FIELDS))
1879 }
1880 }
1881 deserializer.deserialize_identifier(GeneratedVisitor)
1882 }
1883 }
1884 struct GeneratedVisitor;
1885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1886 type Value = BarrierRecvNode;
1887
1888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1889 formatter.write_str("struct stream_plan.BarrierRecvNode")
1890 }
1891
1892 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
1893 where
1894 V: serde::de::MapAccess<'de>,
1895 {
1896 while map_.next_key::<GeneratedField>()?.is_some() {
1897 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1898 }
1899 Ok(BarrierRecvNode {
1900 })
1901 }
1902 }
1903 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
1904 }
1905}
1906impl serde::Serialize for BatchPlanNode {
1907 #[allow(deprecated)]
1908 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1909 where
1910 S: serde::Serializer,
1911 {
1912 use serde::ser::SerializeStruct;
1913 let mut len = 0;
1914 if self.table_desc.is_some() {
1915 len += 1;
1916 }
1917 if !self.column_ids.is_empty() {
1918 len += 1;
1919 }
1920 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
1921 if let Some(v) = self.table_desc.as_ref() {
1922 struct_ser.serialize_field("tableDesc", v)?;
1923 }
1924 if !self.column_ids.is_empty() {
1925 struct_ser.serialize_field("columnIds", &self.column_ids)?;
1926 }
1927 struct_ser.end()
1928 }
1929}
1930impl<'de> serde::Deserialize<'de> for BatchPlanNode {
1931 #[allow(deprecated)]
1932 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1933 where
1934 D: serde::Deserializer<'de>,
1935 {
1936 const FIELDS: &[&str] = &[
1937 "table_desc",
1938 "tableDesc",
1939 "column_ids",
1940 "columnIds",
1941 ];
1942
1943 #[allow(clippy::enum_variant_names)]
1944 enum GeneratedField {
1945 TableDesc,
1946 ColumnIds,
1947 }
1948 impl<'de> serde::Deserialize<'de> for GeneratedField {
1949 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1950 where
1951 D: serde::Deserializer<'de>,
1952 {
1953 struct GeneratedVisitor;
1954
1955 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1956 type Value = GeneratedField;
1957
1958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1959 write!(formatter, "expected one of: {:?}", &FIELDS)
1960 }
1961
1962 #[allow(unused_variables)]
1963 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1964 where
1965 E: serde::de::Error,
1966 {
1967 match value {
1968 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1969 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
1970 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1971 }
1972 }
1973 }
1974 deserializer.deserialize_identifier(GeneratedVisitor)
1975 }
1976 }
1977 struct GeneratedVisitor;
1978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1979 type Value = BatchPlanNode;
1980
1981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1982 formatter.write_str("struct stream_plan.BatchPlanNode")
1983 }
1984
1985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
1986 where
1987 V: serde::de::MapAccess<'de>,
1988 {
1989 let mut table_desc__ = None;
1990 let mut column_ids__ = None;
1991 while let Some(k) = map_.next_key()? {
1992 match k {
1993 GeneratedField::TableDesc => {
1994 if table_desc__.is_some() {
1995 return Err(serde::de::Error::duplicate_field("tableDesc"));
1996 }
1997 table_desc__ = map_.next_value()?;
1998 }
1999 GeneratedField::ColumnIds => {
2000 if column_ids__.is_some() {
2001 return Err(serde::de::Error::duplicate_field("columnIds"));
2002 }
2003 column_ids__ =
2004 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2005 .into_iter().map(|x| x.0).collect())
2006 ;
2007 }
2008 }
2009 }
2010 Ok(BatchPlanNode {
2011 table_desc: table_desc__,
2012 column_ids: column_ids__.unwrap_or_default(),
2013 })
2014 }
2015 }
2016 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2017 }
2018}
2019impl serde::Serialize for CdcFilterNode {
2020 #[allow(deprecated)]
2021 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2022 where
2023 S: serde::Serializer,
2024 {
2025 use serde::ser::SerializeStruct;
2026 let mut len = 0;
2027 if self.search_condition.is_some() {
2028 len += 1;
2029 }
2030 if self.upstream_source_id != 0 {
2031 len += 1;
2032 }
2033 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2034 if let Some(v) = self.search_condition.as_ref() {
2035 struct_ser.serialize_field("searchCondition", v)?;
2036 }
2037 if self.upstream_source_id != 0 {
2038 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2039 }
2040 struct_ser.end()
2041 }
2042}
2043impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2044 #[allow(deprecated)]
2045 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2046 where
2047 D: serde::Deserializer<'de>,
2048 {
2049 const FIELDS: &[&str] = &[
2050 "search_condition",
2051 "searchCondition",
2052 "upstream_source_id",
2053 "upstreamSourceId",
2054 ];
2055
2056 #[allow(clippy::enum_variant_names)]
2057 enum GeneratedField {
2058 SearchCondition,
2059 UpstreamSourceId,
2060 }
2061 impl<'de> serde::Deserialize<'de> for GeneratedField {
2062 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2063 where
2064 D: serde::Deserializer<'de>,
2065 {
2066 struct GeneratedVisitor;
2067
2068 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2069 type Value = GeneratedField;
2070
2071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2072 write!(formatter, "expected one of: {:?}", &FIELDS)
2073 }
2074
2075 #[allow(unused_variables)]
2076 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2077 where
2078 E: serde::de::Error,
2079 {
2080 match value {
2081 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2082 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2083 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2084 }
2085 }
2086 }
2087 deserializer.deserialize_identifier(GeneratedVisitor)
2088 }
2089 }
2090 struct GeneratedVisitor;
2091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2092 type Value = CdcFilterNode;
2093
2094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2095 formatter.write_str("struct stream_plan.CdcFilterNode")
2096 }
2097
2098 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2099 where
2100 V: serde::de::MapAccess<'de>,
2101 {
2102 let mut search_condition__ = None;
2103 let mut upstream_source_id__ = None;
2104 while let Some(k) = map_.next_key()? {
2105 match k {
2106 GeneratedField::SearchCondition => {
2107 if search_condition__.is_some() {
2108 return Err(serde::de::Error::duplicate_field("searchCondition"));
2109 }
2110 search_condition__ = map_.next_value()?;
2111 }
2112 GeneratedField::UpstreamSourceId => {
2113 if upstream_source_id__.is_some() {
2114 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2115 }
2116 upstream_source_id__ =
2117 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2118 ;
2119 }
2120 }
2121 }
2122 Ok(CdcFilterNode {
2123 search_condition: search_condition__,
2124 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2125 })
2126 }
2127 }
2128 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2129 }
2130}
2131impl serde::Serialize for ChangeLogNode {
2132 #[allow(deprecated)]
2133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2134 where
2135 S: serde::Serializer,
2136 {
2137 use serde::ser::SerializeStruct;
2138 let mut len = 0;
2139 if self.need_op {
2140 len += 1;
2141 }
2142 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2143 if self.need_op {
2144 struct_ser.serialize_field("needOp", &self.need_op)?;
2145 }
2146 struct_ser.end()
2147 }
2148}
2149impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2150 #[allow(deprecated)]
2151 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2152 where
2153 D: serde::Deserializer<'de>,
2154 {
2155 const FIELDS: &[&str] = &[
2156 "need_op",
2157 "needOp",
2158 ];
2159
2160 #[allow(clippy::enum_variant_names)]
2161 enum GeneratedField {
2162 NeedOp,
2163 }
2164 impl<'de> serde::Deserialize<'de> for GeneratedField {
2165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2166 where
2167 D: serde::Deserializer<'de>,
2168 {
2169 struct GeneratedVisitor;
2170
2171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2172 type Value = GeneratedField;
2173
2174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2175 write!(formatter, "expected one of: {:?}", &FIELDS)
2176 }
2177
2178 #[allow(unused_variables)]
2179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2180 where
2181 E: serde::de::Error,
2182 {
2183 match value {
2184 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2185 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2186 }
2187 }
2188 }
2189 deserializer.deserialize_identifier(GeneratedVisitor)
2190 }
2191 }
2192 struct GeneratedVisitor;
2193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2194 type Value = ChangeLogNode;
2195
2196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2197 formatter.write_str("struct stream_plan.ChangeLogNode")
2198 }
2199
2200 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2201 where
2202 V: serde::de::MapAccess<'de>,
2203 {
2204 let mut need_op__ = None;
2205 while let Some(k) = map_.next_key()? {
2206 match k {
2207 GeneratedField::NeedOp => {
2208 if need_op__.is_some() {
2209 return Err(serde::de::Error::duplicate_field("needOp"));
2210 }
2211 need_op__ = Some(map_.next_value()?);
2212 }
2213 }
2214 }
2215 Ok(ChangeLogNode {
2216 need_op: need_op__.unwrap_or_default(),
2217 })
2218 }
2219 }
2220 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2221 }
2222}
2223impl serde::Serialize for CombinedMutation {
2224 #[allow(deprecated)]
2225 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2226 where
2227 S: serde::Serializer,
2228 {
2229 use serde::ser::SerializeStruct;
2230 let mut len = 0;
2231 if !self.mutations.is_empty() {
2232 len += 1;
2233 }
2234 let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2235 if !self.mutations.is_empty() {
2236 struct_ser.serialize_field("mutations", &self.mutations)?;
2237 }
2238 struct_ser.end()
2239 }
2240}
2241impl<'de> serde::Deserialize<'de> for CombinedMutation {
2242 #[allow(deprecated)]
2243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2244 where
2245 D: serde::Deserializer<'de>,
2246 {
2247 const FIELDS: &[&str] = &[
2248 "mutations",
2249 ];
2250
2251 #[allow(clippy::enum_variant_names)]
2252 enum GeneratedField {
2253 Mutations,
2254 }
2255 impl<'de> serde::Deserialize<'de> for GeneratedField {
2256 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2257 where
2258 D: serde::Deserializer<'de>,
2259 {
2260 struct GeneratedVisitor;
2261
2262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2263 type Value = GeneratedField;
2264
2265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2266 write!(formatter, "expected one of: {:?}", &FIELDS)
2267 }
2268
2269 #[allow(unused_variables)]
2270 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2271 where
2272 E: serde::de::Error,
2273 {
2274 match value {
2275 "mutations" => Ok(GeneratedField::Mutations),
2276 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2277 }
2278 }
2279 }
2280 deserializer.deserialize_identifier(GeneratedVisitor)
2281 }
2282 }
2283 struct GeneratedVisitor;
2284 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2285 type Value = CombinedMutation;
2286
2287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2288 formatter.write_str("struct stream_plan.CombinedMutation")
2289 }
2290
2291 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2292 where
2293 V: serde::de::MapAccess<'de>,
2294 {
2295 let mut mutations__ = None;
2296 while let Some(k) = map_.next_key()? {
2297 match k {
2298 GeneratedField::Mutations => {
2299 if mutations__.is_some() {
2300 return Err(serde::de::Error::duplicate_field("mutations"));
2301 }
2302 mutations__ = Some(map_.next_value()?);
2303 }
2304 }
2305 }
2306 Ok(CombinedMutation {
2307 mutations: mutations__.unwrap_or_default(),
2308 })
2309 }
2310 }
2311 deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2312 }
2313}
2314impl serde::Serialize for ConnectorPropsChangeMutation {
2315 #[allow(deprecated)]
2316 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2317 where
2318 S: serde::Serializer,
2319 {
2320 use serde::ser::SerializeStruct;
2321 let mut len = 0;
2322 if !self.connector_props_infos.is_empty() {
2323 len += 1;
2324 }
2325 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2326 if !self.connector_props_infos.is_empty() {
2327 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2328 }
2329 struct_ser.end()
2330 }
2331}
2332impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2333 #[allow(deprecated)]
2334 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2335 where
2336 D: serde::Deserializer<'de>,
2337 {
2338 const FIELDS: &[&str] = &[
2339 "connector_props_infos",
2340 "connectorPropsInfos",
2341 ];
2342
2343 #[allow(clippy::enum_variant_names)]
2344 enum GeneratedField {
2345 ConnectorPropsInfos,
2346 }
2347 impl<'de> serde::Deserialize<'de> for GeneratedField {
2348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2349 where
2350 D: serde::Deserializer<'de>,
2351 {
2352 struct GeneratedVisitor;
2353
2354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2355 type Value = GeneratedField;
2356
2357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2358 write!(formatter, "expected one of: {:?}", &FIELDS)
2359 }
2360
2361 #[allow(unused_variables)]
2362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2363 where
2364 E: serde::de::Error,
2365 {
2366 match value {
2367 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2368 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2369 }
2370 }
2371 }
2372 deserializer.deserialize_identifier(GeneratedVisitor)
2373 }
2374 }
2375 struct GeneratedVisitor;
2376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2377 type Value = ConnectorPropsChangeMutation;
2378
2379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2380 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2381 }
2382
2383 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2384 where
2385 V: serde::de::MapAccess<'de>,
2386 {
2387 let mut connector_props_infos__ = None;
2388 while let Some(k) = map_.next_key()? {
2389 match k {
2390 GeneratedField::ConnectorPropsInfos => {
2391 if connector_props_infos__.is_some() {
2392 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2393 }
2394 connector_props_infos__ = Some(
2395 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2396 .into_iter().map(|(k,v)| (k.0, v)).collect()
2397 );
2398 }
2399 }
2400 }
2401 Ok(ConnectorPropsChangeMutation {
2402 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2403 })
2404 }
2405 }
2406 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2407 }
2408}
2409impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2410 #[allow(deprecated)]
2411 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2412 where
2413 S: serde::Serializer,
2414 {
2415 use serde::ser::SerializeStruct;
2416 let mut len = 0;
2417 if !self.connector_props_info.is_empty() {
2418 len += 1;
2419 }
2420 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2421 if !self.connector_props_info.is_empty() {
2422 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2423 }
2424 struct_ser.end()
2425 }
2426}
2427impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2428 #[allow(deprecated)]
2429 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2430 where
2431 D: serde::Deserializer<'de>,
2432 {
2433 const FIELDS: &[&str] = &[
2434 "connector_props_info",
2435 "connectorPropsInfo",
2436 ];
2437
2438 #[allow(clippy::enum_variant_names)]
2439 enum GeneratedField {
2440 ConnectorPropsInfo,
2441 }
2442 impl<'de> serde::Deserialize<'de> for GeneratedField {
2443 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2444 where
2445 D: serde::Deserializer<'de>,
2446 {
2447 struct GeneratedVisitor;
2448
2449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2450 type Value = GeneratedField;
2451
2452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2453 write!(formatter, "expected one of: {:?}", &FIELDS)
2454 }
2455
2456 #[allow(unused_variables)]
2457 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2458 where
2459 E: serde::de::Error,
2460 {
2461 match value {
2462 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2463 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2464 }
2465 }
2466 }
2467 deserializer.deserialize_identifier(GeneratedVisitor)
2468 }
2469 }
2470 struct GeneratedVisitor;
2471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2472 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2473
2474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2475 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2476 }
2477
2478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2479 where
2480 V: serde::de::MapAccess<'de>,
2481 {
2482 let mut connector_props_info__ = None;
2483 while let Some(k) = map_.next_key()? {
2484 match k {
2485 GeneratedField::ConnectorPropsInfo => {
2486 if connector_props_info__.is_some() {
2487 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2488 }
2489 connector_props_info__ = Some(
2490 map_.next_value::<std::collections::HashMap<_, _>>()?
2491 );
2492 }
2493 }
2494 }
2495 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2496 connector_props_info: connector_props_info__.unwrap_or_default(),
2497 })
2498 }
2499 }
2500 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2501 }
2502}
2503impl serde::Serialize for DedupNode {
2504 #[allow(deprecated)]
2505 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2506 where
2507 S: serde::Serializer,
2508 {
2509 use serde::ser::SerializeStruct;
2510 let mut len = 0;
2511 if self.state_table.is_some() {
2512 len += 1;
2513 }
2514 if !self.dedup_column_indices.is_empty() {
2515 len += 1;
2516 }
2517 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2518 if let Some(v) = self.state_table.as_ref() {
2519 struct_ser.serialize_field("stateTable", v)?;
2520 }
2521 if !self.dedup_column_indices.is_empty() {
2522 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2523 }
2524 struct_ser.end()
2525 }
2526}
2527impl<'de> serde::Deserialize<'de> for DedupNode {
2528 #[allow(deprecated)]
2529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2530 where
2531 D: serde::Deserializer<'de>,
2532 {
2533 const FIELDS: &[&str] = &[
2534 "state_table",
2535 "stateTable",
2536 "dedup_column_indices",
2537 "dedupColumnIndices",
2538 ];
2539
2540 #[allow(clippy::enum_variant_names)]
2541 enum GeneratedField {
2542 StateTable,
2543 DedupColumnIndices,
2544 }
2545 impl<'de> serde::Deserialize<'de> for GeneratedField {
2546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2547 where
2548 D: serde::Deserializer<'de>,
2549 {
2550 struct GeneratedVisitor;
2551
2552 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2553 type Value = GeneratedField;
2554
2555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2556 write!(formatter, "expected one of: {:?}", &FIELDS)
2557 }
2558
2559 #[allow(unused_variables)]
2560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2561 where
2562 E: serde::de::Error,
2563 {
2564 match value {
2565 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2566 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2567 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2568 }
2569 }
2570 }
2571 deserializer.deserialize_identifier(GeneratedVisitor)
2572 }
2573 }
2574 struct GeneratedVisitor;
2575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2576 type Value = DedupNode;
2577
2578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2579 formatter.write_str("struct stream_plan.DedupNode")
2580 }
2581
2582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2583 where
2584 V: serde::de::MapAccess<'de>,
2585 {
2586 let mut state_table__ = None;
2587 let mut dedup_column_indices__ = None;
2588 while let Some(k) = map_.next_key()? {
2589 match k {
2590 GeneratedField::StateTable => {
2591 if state_table__.is_some() {
2592 return Err(serde::de::Error::duplicate_field("stateTable"));
2593 }
2594 state_table__ = map_.next_value()?;
2595 }
2596 GeneratedField::DedupColumnIndices => {
2597 if dedup_column_indices__.is_some() {
2598 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2599 }
2600 dedup_column_indices__ =
2601 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2602 .into_iter().map(|x| x.0).collect())
2603 ;
2604 }
2605 }
2606 }
2607 Ok(DedupNode {
2608 state_table: state_table__,
2609 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2610 })
2611 }
2612 }
2613 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2614 }
2615}
2616impl serde::Serialize for DeltaExpression {
2617 #[allow(deprecated)]
2618 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2619 where
2620 S: serde::Serializer,
2621 {
2622 use serde::ser::SerializeStruct;
2623 let mut len = 0;
2624 if self.delta_type != 0 {
2625 len += 1;
2626 }
2627 if self.delta.is_some() {
2628 len += 1;
2629 }
2630 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2631 if self.delta_type != 0 {
2632 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2633 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2634 struct_ser.serialize_field("deltaType", &v)?;
2635 }
2636 if let Some(v) = self.delta.as_ref() {
2637 struct_ser.serialize_field("delta", v)?;
2638 }
2639 struct_ser.end()
2640 }
2641}
2642impl<'de> serde::Deserialize<'de> for DeltaExpression {
2643 #[allow(deprecated)]
2644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2645 where
2646 D: serde::Deserializer<'de>,
2647 {
2648 const FIELDS: &[&str] = &[
2649 "delta_type",
2650 "deltaType",
2651 "delta",
2652 ];
2653
2654 #[allow(clippy::enum_variant_names)]
2655 enum GeneratedField {
2656 DeltaType,
2657 Delta,
2658 }
2659 impl<'de> serde::Deserialize<'de> for GeneratedField {
2660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2661 where
2662 D: serde::Deserializer<'de>,
2663 {
2664 struct GeneratedVisitor;
2665
2666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2667 type Value = GeneratedField;
2668
2669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2670 write!(formatter, "expected one of: {:?}", &FIELDS)
2671 }
2672
2673 #[allow(unused_variables)]
2674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2675 where
2676 E: serde::de::Error,
2677 {
2678 match value {
2679 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2680 "delta" => Ok(GeneratedField::Delta),
2681 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2682 }
2683 }
2684 }
2685 deserializer.deserialize_identifier(GeneratedVisitor)
2686 }
2687 }
2688 struct GeneratedVisitor;
2689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2690 type Value = DeltaExpression;
2691
2692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2693 formatter.write_str("struct stream_plan.DeltaExpression")
2694 }
2695
2696 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2697 where
2698 V: serde::de::MapAccess<'de>,
2699 {
2700 let mut delta_type__ = None;
2701 let mut delta__ = None;
2702 while let Some(k) = map_.next_key()? {
2703 match k {
2704 GeneratedField::DeltaType => {
2705 if delta_type__.is_some() {
2706 return Err(serde::de::Error::duplicate_field("deltaType"));
2707 }
2708 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2709 }
2710 GeneratedField::Delta => {
2711 if delta__.is_some() {
2712 return Err(serde::de::Error::duplicate_field("delta"));
2713 }
2714 delta__ = map_.next_value()?;
2715 }
2716 }
2717 }
2718 Ok(DeltaExpression {
2719 delta_type: delta_type__.unwrap_or_default(),
2720 delta: delta__,
2721 })
2722 }
2723 }
2724 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2725 }
2726}
2727impl serde::Serialize for DeltaIndexJoinNode {
2728 #[allow(deprecated)]
2729 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2730 where
2731 S: serde::Serializer,
2732 {
2733 use serde::ser::SerializeStruct;
2734 let mut len = 0;
2735 if self.join_type != 0 {
2736 len += 1;
2737 }
2738 if !self.left_key.is_empty() {
2739 len += 1;
2740 }
2741 if !self.right_key.is_empty() {
2742 len += 1;
2743 }
2744 if self.condition.is_some() {
2745 len += 1;
2746 }
2747 if self.left_table_id != 0 {
2748 len += 1;
2749 }
2750 if self.right_table_id != 0 {
2751 len += 1;
2752 }
2753 if self.left_info.is_some() {
2754 len += 1;
2755 }
2756 if self.right_info.is_some() {
2757 len += 1;
2758 }
2759 if !self.output_indices.is_empty() {
2760 len += 1;
2761 }
2762 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2763 if self.join_type != 0 {
2764 let v = super::plan_common::JoinType::try_from(self.join_type)
2765 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2766 struct_ser.serialize_field("joinType", &v)?;
2767 }
2768 if !self.left_key.is_empty() {
2769 struct_ser.serialize_field("leftKey", &self.left_key)?;
2770 }
2771 if !self.right_key.is_empty() {
2772 struct_ser.serialize_field("rightKey", &self.right_key)?;
2773 }
2774 if let Some(v) = self.condition.as_ref() {
2775 struct_ser.serialize_field("condition", v)?;
2776 }
2777 if self.left_table_id != 0 {
2778 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2779 }
2780 if self.right_table_id != 0 {
2781 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2782 }
2783 if let Some(v) = self.left_info.as_ref() {
2784 struct_ser.serialize_field("leftInfo", v)?;
2785 }
2786 if let Some(v) = self.right_info.as_ref() {
2787 struct_ser.serialize_field("rightInfo", v)?;
2788 }
2789 if !self.output_indices.is_empty() {
2790 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2791 }
2792 struct_ser.end()
2793 }
2794}
2795impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
2796 #[allow(deprecated)]
2797 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2798 where
2799 D: serde::Deserializer<'de>,
2800 {
2801 const FIELDS: &[&str] = &[
2802 "join_type",
2803 "joinType",
2804 "left_key",
2805 "leftKey",
2806 "right_key",
2807 "rightKey",
2808 "condition",
2809 "left_table_id",
2810 "leftTableId",
2811 "right_table_id",
2812 "rightTableId",
2813 "left_info",
2814 "leftInfo",
2815 "right_info",
2816 "rightInfo",
2817 "output_indices",
2818 "outputIndices",
2819 ];
2820
2821 #[allow(clippy::enum_variant_names)]
2822 enum GeneratedField {
2823 JoinType,
2824 LeftKey,
2825 RightKey,
2826 Condition,
2827 LeftTableId,
2828 RightTableId,
2829 LeftInfo,
2830 RightInfo,
2831 OutputIndices,
2832 }
2833 impl<'de> serde::Deserialize<'de> for GeneratedField {
2834 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2835 where
2836 D: serde::Deserializer<'de>,
2837 {
2838 struct GeneratedVisitor;
2839
2840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2841 type Value = GeneratedField;
2842
2843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2844 write!(formatter, "expected one of: {:?}", &FIELDS)
2845 }
2846
2847 #[allow(unused_variables)]
2848 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2849 where
2850 E: serde::de::Error,
2851 {
2852 match value {
2853 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
2854 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
2855 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
2856 "condition" => Ok(GeneratedField::Condition),
2857 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
2858 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
2859 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
2860 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
2861 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2862 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2863 }
2864 }
2865 }
2866 deserializer.deserialize_identifier(GeneratedVisitor)
2867 }
2868 }
2869 struct GeneratedVisitor;
2870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2871 type Value = DeltaIndexJoinNode;
2872
2873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2874 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
2875 }
2876
2877 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
2878 where
2879 V: serde::de::MapAccess<'de>,
2880 {
2881 let mut join_type__ = None;
2882 let mut left_key__ = None;
2883 let mut right_key__ = None;
2884 let mut condition__ = None;
2885 let mut left_table_id__ = None;
2886 let mut right_table_id__ = None;
2887 let mut left_info__ = None;
2888 let mut right_info__ = None;
2889 let mut output_indices__ = None;
2890 while let Some(k) = map_.next_key()? {
2891 match k {
2892 GeneratedField::JoinType => {
2893 if join_type__.is_some() {
2894 return Err(serde::de::Error::duplicate_field("joinType"));
2895 }
2896 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
2897 }
2898 GeneratedField::LeftKey => {
2899 if left_key__.is_some() {
2900 return Err(serde::de::Error::duplicate_field("leftKey"));
2901 }
2902 left_key__ =
2903 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2904 .into_iter().map(|x| x.0).collect())
2905 ;
2906 }
2907 GeneratedField::RightKey => {
2908 if right_key__.is_some() {
2909 return Err(serde::de::Error::duplicate_field("rightKey"));
2910 }
2911 right_key__ =
2912 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2913 .into_iter().map(|x| x.0).collect())
2914 ;
2915 }
2916 GeneratedField::Condition => {
2917 if condition__.is_some() {
2918 return Err(serde::de::Error::duplicate_field("condition"));
2919 }
2920 condition__ = map_.next_value()?;
2921 }
2922 GeneratedField::LeftTableId => {
2923 if left_table_id__.is_some() {
2924 return Err(serde::de::Error::duplicate_field("leftTableId"));
2925 }
2926 left_table_id__ =
2927 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2928 ;
2929 }
2930 GeneratedField::RightTableId => {
2931 if right_table_id__.is_some() {
2932 return Err(serde::de::Error::duplicate_field("rightTableId"));
2933 }
2934 right_table_id__ =
2935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2936 ;
2937 }
2938 GeneratedField::LeftInfo => {
2939 if left_info__.is_some() {
2940 return Err(serde::de::Error::duplicate_field("leftInfo"));
2941 }
2942 left_info__ = map_.next_value()?;
2943 }
2944 GeneratedField::RightInfo => {
2945 if right_info__.is_some() {
2946 return Err(serde::de::Error::duplicate_field("rightInfo"));
2947 }
2948 right_info__ = map_.next_value()?;
2949 }
2950 GeneratedField::OutputIndices => {
2951 if output_indices__.is_some() {
2952 return Err(serde::de::Error::duplicate_field("outputIndices"));
2953 }
2954 output_indices__ =
2955 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2956 .into_iter().map(|x| x.0).collect())
2957 ;
2958 }
2959 }
2960 }
2961 Ok(DeltaIndexJoinNode {
2962 join_type: join_type__.unwrap_or_default(),
2963 left_key: left_key__.unwrap_or_default(),
2964 right_key: right_key__.unwrap_or_default(),
2965 condition: condition__,
2966 left_table_id: left_table_id__.unwrap_or_default(),
2967 right_table_id: right_table_id__.unwrap_or_default(),
2968 left_info: left_info__,
2969 right_info: right_info__,
2970 output_indices: output_indices__.unwrap_or_default(),
2971 })
2972 }
2973 }
2974 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
2975 }
2976}
2977impl serde::Serialize for DispatchStrategy {
2978 #[allow(deprecated)]
2979 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2980 where
2981 S: serde::Serializer,
2982 {
2983 use serde::ser::SerializeStruct;
2984 let mut len = 0;
2985 if self.r#type != 0 {
2986 len += 1;
2987 }
2988 if !self.dist_key_indices.is_empty() {
2989 len += 1;
2990 }
2991 if !self.output_indices.is_empty() {
2992 len += 1;
2993 }
2994 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
2995 if self.r#type != 0 {
2996 let v = DispatcherType::try_from(self.r#type)
2997 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
2998 struct_ser.serialize_field("type", &v)?;
2999 }
3000 if !self.dist_key_indices.is_empty() {
3001 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3002 }
3003 if !self.output_indices.is_empty() {
3004 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3005 }
3006 struct_ser.end()
3007 }
3008}
3009impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3010 #[allow(deprecated)]
3011 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3012 where
3013 D: serde::Deserializer<'de>,
3014 {
3015 const FIELDS: &[&str] = &[
3016 "type",
3017 "dist_key_indices",
3018 "distKeyIndices",
3019 "output_indices",
3020 "outputIndices",
3021 ];
3022
3023 #[allow(clippy::enum_variant_names)]
3024 enum GeneratedField {
3025 Type,
3026 DistKeyIndices,
3027 OutputIndices,
3028 }
3029 impl<'de> serde::Deserialize<'de> for GeneratedField {
3030 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3031 where
3032 D: serde::Deserializer<'de>,
3033 {
3034 struct GeneratedVisitor;
3035
3036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3037 type Value = GeneratedField;
3038
3039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3040 write!(formatter, "expected one of: {:?}", &FIELDS)
3041 }
3042
3043 #[allow(unused_variables)]
3044 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3045 where
3046 E: serde::de::Error,
3047 {
3048 match value {
3049 "type" => Ok(GeneratedField::Type),
3050 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3051 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3052 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3053 }
3054 }
3055 }
3056 deserializer.deserialize_identifier(GeneratedVisitor)
3057 }
3058 }
3059 struct GeneratedVisitor;
3060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3061 type Value = DispatchStrategy;
3062
3063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3064 formatter.write_str("struct stream_plan.DispatchStrategy")
3065 }
3066
3067 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3068 where
3069 V: serde::de::MapAccess<'de>,
3070 {
3071 let mut r#type__ = None;
3072 let mut dist_key_indices__ = None;
3073 let mut output_indices__ = None;
3074 while let Some(k) = map_.next_key()? {
3075 match k {
3076 GeneratedField::Type => {
3077 if r#type__.is_some() {
3078 return Err(serde::de::Error::duplicate_field("type"));
3079 }
3080 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3081 }
3082 GeneratedField::DistKeyIndices => {
3083 if dist_key_indices__.is_some() {
3084 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3085 }
3086 dist_key_indices__ =
3087 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3088 .into_iter().map(|x| x.0).collect())
3089 ;
3090 }
3091 GeneratedField::OutputIndices => {
3092 if output_indices__.is_some() {
3093 return Err(serde::de::Error::duplicate_field("outputIndices"));
3094 }
3095 output_indices__ =
3096 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3097 .into_iter().map(|x| x.0).collect())
3098 ;
3099 }
3100 }
3101 }
3102 Ok(DispatchStrategy {
3103 r#type: r#type__.unwrap_or_default(),
3104 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3105 output_indices: output_indices__.unwrap_or_default(),
3106 })
3107 }
3108 }
3109 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3110 }
3111}
3112impl serde::Serialize for Dispatcher {
3113 #[allow(deprecated)]
3114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3115 where
3116 S: serde::Serializer,
3117 {
3118 use serde::ser::SerializeStruct;
3119 let mut len = 0;
3120 if self.r#type != 0 {
3121 len += 1;
3122 }
3123 if !self.dist_key_indices.is_empty() {
3124 len += 1;
3125 }
3126 if !self.output_indices.is_empty() {
3127 len += 1;
3128 }
3129 if self.hash_mapping.is_some() {
3130 len += 1;
3131 }
3132 if self.dispatcher_id != 0 {
3133 len += 1;
3134 }
3135 if !self.downstream_actor_id.is_empty() {
3136 len += 1;
3137 }
3138 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3139 if self.r#type != 0 {
3140 let v = DispatcherType::try_from(self.r#type)
3141 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3142 struct_ser.serialize_field("type", &v)?;
3143 }
3144 if !self.dist_key_indices.is_empty() {
3145 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3146 }
3147 if !self.output_indices.is_empty() {
3148 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3149 }
3150 if let Some(v) = self.hash_mapping.as_ref() {
3151 struct_ser.serialize_field("hashMapping", v)?;
3152 }
3153 if self.dispatcher_id != 0 {
3154 #[allow(clippy::needless_borrow)]
3155 #[allow(clippy::needless_borrows_for_generic_args)]
3156 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3157 }
3158 if !self.downstream_actor_id.is_empty() {
3159 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3160 }
3161 struct_ser.end()
3162 }
3163}
3164impl<'de> serde::Deserialize<'de> for Dispatcher {
3165 #[allow(deprecated)]
3166 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3167 where
3168 D: serde::Deserializer<'de>,
3169 {
3170 const FIELDS: &[&str] = &[
3171 "type",
3172 "dist_key_indices",
3173 "distKeyIndices",
3174 "output_indices",
3175 "outputIndices",
3176 "hash_mapping",
3177 "hashMapping",
3178 "dispatcher_id",
3179 "dispatcherId",
3180 "downstream_actor_id",
3181 "downstreamActorId",
3182 ];
3183
3184 #[allow(clippy::enum_variant_names)]
3185 enum GeneratedField {
3186 Type,
3187 DistKeyIndices,
3188 OutputIndices,
3189 HashMapping,
3190 DispatcherId,
3191 DownstreamActorId,
3192 }
3193 impl<'de> serde::Deserialize<'de> for GeneratedField {
3194 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3195 where
3196 D: serde::Deserializer<'de>,
3197 {
3198 struct GeneratedVisitor;
3199
3200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3201 type Value = GeneratedField;
3202
3203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3204 write!(formatter, "expected one of: {:?}", &FIELDS)
3205 }
3206
3207 #[allow(unused_variables)]
3208 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3209 where
3210 E: serde::de::Error,
3211 {
3212 match value {
3213 "type" => Ok(GeneratedField::Type),
3214 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3215 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3216 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3217 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3218 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3220 }
3221 }
3222 }
3223 deserializer.deserialize_identifier(GeneratedVisitor)
3224 }
3225 }
3226 struct GeneratedVisitor;
3227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3228 type Value = Dispatcher;
3229
3230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3231 formatter.write_str("struct stream_plan.Dispatcher")
3232 }
3233
3234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3235 where
3236 V: serde::de::MapAccess<'de>,
3237 {
3238 let mut r#type__ = None;
3239 let mut dist_key_indices__ = None;
3240 let mut output_indices__ = None;
3241 let mut hash_mapping__ = None;
3242 let mut dispatcher_id__ = None;
3243 let mut downstream_actor_id__ = None;
3244 while let Some(k) = map_.next_key()? {
3245 match k {
3246 GeneratedField::Type => {
3247 if r#type__.is_some() {
3248 return Err(serde::de::Error::duplicate_field("type"));
3249 }
3250 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3251 }
3252 GeneratedField::DistKeyIndices => {
3253 if dist_key_indices__.is_some() {
3254 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3255 }
3256 dist_key_indices__ =
3257 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3258 .into_iter().map(|x| x.0).collect())
3259 ;
3260 }
3261 GeneratedField::OutputIndices => {
3262 if output_indices__.is_some() {
3263 return Err(serde::de::Error::duplicate_field("outputIndices"));
3264 }
3265 output_indices__ =
3266 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3267 .into_iter().map(|x| x.0).collect())
3268 ;
3269 }
3270 GeneratedField::HashMapping => {
3271 if hash_mapping__.is_some() {
3272 return Err(serde::de::Error::duplicate_field("hashMapping"));
3273 }
3274 hash_mapping__ = map_.next_value()?;
3275 }
3276 GeneratedField::DispatcherId => {
3277 if dispatcher_id__.is_some() {
3278 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3279 }
3280 dispatcher_id__ =
3281 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3282 ;
3283 }
3284 GeneratedField::DownstreamActorId => {
3285 if downstream_actor_id__.is_some() {
3286 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3287 }
3288 downstream_actor_id__ =
3289 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3290 .into_iter().map(|x| x.0).collect())
3291 ;
3292 }
3293 }
3294 }
3295 Ok(Dispatcher {
3296 r#type: r#type__.unwrap_or_default(),
3297 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3298 output_indices: output_indices__.unwrap_or_default(),
3299 hash_mapping: hash_mapping__,
3300 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3301 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3302 })
3303 }
3304 }
3305 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3306 }
3307}
3308impl serde::Serialize for DispatcherType {
3309 #[allow(deprecated)]
3310 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3311 where
3312 S: serde::Serializer,
3313 {
3314 let variant = match self {
3315 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3316 Self::Hash => "DISPATCHER_TYPE_HASH",
3317 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3318 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3319 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3320 };
3321 serializer.serialize_str(variant)
3322 }
3323}
3324impl<'de> serde::Deserialize<'de> for DispatcherType {
3325 #[allow(deprecated)]
3326 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3327 where
3328 D: serde::Deserializer<'de>,
3329 {
3330 const FIELDS: &[&str] = &[
3331 "DISPATCHER_TYPE_UNSPECIFIED",
3332 "DISPATCHER_TYPE_HASH",
3333 "DISPATCHER_TYPE_BROADCAST",
3334 "DISPATCHER_TYPE_SIMPLE",
3335 "DISPATCHER_TYPE_NO_SHUFFLE",
3336 ];
3337
3338 struct GeneratedVisitor;
3339
3340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3341 type Value = DispatcherType;
3342
3343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3344 write!(formatter, "expected one of: {:?}", &FIELDS)
3345 }
3346
3347 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3348 where
3349 E: serde::de::Error,
3350 {
3351 i32::try_from(v)
3352 .ok()
3353 .and_then(|x| x.try_into().ok())
3354 .ok_or_else(|| {
3355 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3356 })
3357 }
3358
3359 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3360 where
3361 E: serde::de::Error,
3362 {
3363 i32::try_from(v)
3364 .ok()
3365 .and_then(|x| x.try_into().ok())
3366 .ok_or_else(|| {
3367 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3368 })
3369 }
3370
3371 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3372 where
3373 E: serde::de::Error,
3374 {
3375 match value {
3376 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3377 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3378 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3379 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3380 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3381 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3382 }
3383 }
3384 }
3385 deserializer.deserialize_any(GeneratedVisitor)
3386 }
3387}
3388impl serde::Serialize for Dispatchers {
3389 #[allow(deprecated)]
3390 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3391 where
3392 S: serde::Serializer,
3393 {
3394 use serde::ser::SerializeStruct;
3395 let mut len = 0;
3396 if !self.dispatchers.is_empty() {
3397 len += 1;
3398 }
3399 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3400 if !self.dispatchers.is_empty() {
3401 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3402 }
3403 struct_ser.end()
3404 }
3405}
3406impl<'de> serde::Deserialize<'de> for Dispatchers {
3407 #[allow(deprecated)]
3408 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3409 where
3410 D: serde::Deserializer<'de>,
3411 {
3412 const FIELDS: &[&str] = &[
3413 "dispatchers",
3414 ];
3415
3416 #[allow(clippy::enum_variant_names)]
3417 enum GeneratedField {
3418 Dispatchers,
3419 }
3420 impl<'de> serde::Deserialize<'de> for GeneratedField {
3421 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3422 where
3423 D: serde::Deserializer<'de>,
3424 {
3425 struct GeneratedVisitor;
3426
3427 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3428 type Value = GeneratedField;
3429
3430 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3431 write!(formatter, "expected one of: {:?}", &FIELDS)
3432 }
3433
3434 #[allow(unused_variables)]
3435 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3436 where
3437 E: serde::de::Error,
3438 {
3439 match value {
3440 "dispatchers" => Ok(GeneratedField::Dispatchers),
3441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3442 }
3443 }
3444 }
3445 deserializer.deserialize_identifier(GeneratedVisitor)
3446 }
3447 }
3448 struct GeneratedVisitor;
3449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3450 type Value = Dispatchers;
3451
3452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3453 formatter.write_str("struct stream_plan.Dispatchers")
3454 }
3455
3456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3457 where
3458 V: serde::de::MapAccess<'de>,
3459 {
3460 let mut dispatchers__ = None;
3461 while let Some(k) = map_.next_key()? {
3462 match k {
3463 GeneratedField::Dispatchers => {
3464 if dispatchers__.is_some() {
3465 return Err(serde::de::Error::duplicate_field("dispatchers"));
3466 }
3467 dispatchers__ = Some(map_.next_value()?);
3468 }
3469 }
3470 }
3471 Ok(Dispatchers {
3472 dispatchers: dispatchers__.unwrap_or_default(),
3473 })
3474 }
3475 }
3476 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3477 }
3478}
3479impl serde::Serialize for DmlNode {
3480 #[allow(deprecated)]
3481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3482 where
3483 S: serde::Serializer,
3484 {
3485 use serde::ser::SerializeStruct;
3486 let mut len = 0;
3487 if self.table_id != 0 {
3488 len += 1;
3489 }
3490 if self.table_version_id != 0 {
3491 len += 1;
3492 }
3493 if !self.column_descs.is_empty() {
3494 len += 1;
3495 }
3496 if self.rate_limit.is_some() {
3497 len += 1;
3498 }
3499 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3500 if self.table_id != 0 {
3501 struct_ser.serialize_field("tableId", &self.table_id)?;
3502 }
3503 if self.table_version_id != 0 {
3504 #[allow(clippy::needless_borrow)]
3505 #[allow(clippy::needless_borrows_for_generic_args)]
3506 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3507 }
3508 if !self.column_descs.is_empty() {
3509 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3510 }
3511 if let Some(v) = self.rate_limit.as_ref() {
3512 struct_ser.serialize_field("rateLimit", v)?;
3513 }
3514 struct_ser.end()
3515 }
3516}
3517impl<'de> serde::Deserialize<'de> for DmlNode {
3518 #[allow(deprecated)]
3519 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3520 where
3521 D: serde::Deserializer<'de>,
3522 {
3523 const FIELDS: &[&str] = &[
3524 "table_id",
3525 "tableId",
3526 "table_version_id",
3527 "tableVersionId",
3528 "column_descs",
3529 "columnDescs",
3530 "rate_limit",
3531 "rateLimit",
3532 ];
3533
3534 #[allow(clippy::enum_variant_names)]
3535 enum GeneratedField {
3536 TableId,
3537 TableVersionId,
3538 ColumnDescs,
3539 RateLimit,
3540 }
3541 impl<'de> serde::Deserialize<'de> for GeneratedField {
3542 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3543 where
3544 D: serde::Deserializer<'de>,
3545 {
3546 struct GeneratedVisitor;
3547
3548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3549 type Value = GeneratedField;
3550
3551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3552 write!(formatter, "expected one of: {:?}", &FIELDS)
3553 }
3554
3555 #[allow(unused_variables)]
3556 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3557 where
3558 E: serde::de::Error,
3559 {
3560 match value {
3561 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3562 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3563 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3564 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3565 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3566 }
3567 }
3568 }
3569 deserializer.deserialize_identifier(GeneratedVisitor)
3570 }
3571 }
3572 struct GeneratedVisitor;
3573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3574 type Value = DmlNode;
3575
3576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3577 formatter.write_str("struct stream_plan.DmlNode")
3578 }
3579
3580 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
3581 where
3582 V: serde::de::MapAccess<'de>,
3583 {
3584 let mut table_id__ = None;
3585 let mut table_version_id__ = None;
3586 let mut column_descs__ = None;
3587 let mut rate_limit__ = None;
3588 while let Some(k) = map_.next_key()? {
3589 match k {
3590 GeneratedField::TableId => {
3591 if table_id__.is_some() {
3592 return Err(serde::de::Error::duplicate_field("tableId"));
3593 }
3594 table_id__ =
3595 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3596 ;
3597 }
3598 GeneratedField::TableVersionId => {
3599 if table_version_id__.is_some() {
3600 return Err(serde::de::Error::duplicate_field("tableVersionId"));
3601 }
3602 table_version_id__ =
3603 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3604 ;
3605 }
3606 GeneratedField::ColumnDescs => {
3607 if column_descs__.is_some() {
3608 return Err(serde::de::Error::duplicate_field("columnDescs"));
3609 }
3610 column_descs__ = Some(map_.next_value()?);
3611 }
3612 GeneratedField::RateLimit => {
3613 if rate_limit__.is_some() {
3614 return Err(serde::de::Error::duplicate_field("rateLimit"));
3615 }
3616 rate_limit__ =
3617 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3618 ;
3619 }
3620 }
3621 }
3622 Ok(DmlNode {
3623 table_id: table_id__.unwrap_or_default(),
3624 table_version_id: table_version_id__.unwrap_or_default(),
3625 column_descs: column_descs__.unwrap_or_default(),
3626 rate_limit: rate_limit__,
3627 })
3628 }
3629 }
3630 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
3631 }
3632}
3633impl serde::Serialize for DropSubscriptionsMutation {
3634 #[allow(deprecated)]
3635 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3636 where
3637 S: serde::Serializer,
3638 {
3639 use serde::ser::SerializeStruct;
3640 let mut len = 0;
3641 if !self.info.is_empty() {
3642 len += 1;
3643 }
3644 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
3645 if !self.info.is_empty() {
3646 struct_ser.serialize_field("info", &self.info)?;
3647 }
3648 struct_ser.end()
3649 }
3650}
3651impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
3652 #[allow(deprecated)]
3653 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3654 where
3655 D: serde::Deserializer<'de>,
3656 {
3657 const FIELDS: &[&str] = &[
3658 "info",
3659 ];
3660
3661 #[allow(clippy::enum_variant_names)]
3662 enum GeneratedField {
3663 Info,
3664 }
3665 impl<'de> serde::Deserialize<'de> for GeneratedField {
3666 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3667 where
3668 D: serde::Deserializer<'de>,
3669 {
3670 struct GeneratedVisitor;
3671
3672 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3673 type Value = GeneratedField;
3674
3675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3676 write!(formatter, "expected one of: {:?}", &FIELDS)
3677 }
3678
3679 #[allow(unused_variables)]
3680 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3681 where
3682 E: serde::de::Error,
3683 {
3684 match value {
3685 "info" => Ok(GeneratedField::Info),
3686 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3687 }
3688 }
3689 }
3690 deserializer.deserialize_identifier(GeneratedVisitor)
3691 }
3692 }
3693 struct GeneratedVisitor;
3694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3695 type Value = DropSubscriptionsMutation;
3696
3697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3698 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
3699 }
3700
3701 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
3702 where
3703 V: serde::de::MapAccess<'de>,
3704 {
3705 let mut info__ = None;
3706 while let Some(k) = map_.next_key()? {
3707 match k {
3708 GeneratedField::Info => {
3709 if info__.is_some() {
3710 return Err(serde::de::Error::duplicate_field("info"));
3711 }
3712 info__ = Some(map_.next_value()?);
3713 }
3714 }
3715 }
3716 Ok(DropSubscriptionsMutation {
3717 info: info__.unwrap_or_default(),
3718 })
3719 }
3720 }
3721 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
3722 }
3723}
3724impl serde::Serialize for DynamicFilterNode {
3725 #[allow(deprecated)]
3726 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3727 where
3728 S: serde::Serializer,
3729 {
3730 use serde::ser::SerializeStruct;
3731 let mut len = 0;
3732 if self.left_key != 0 {
3733 len += 1;
3734 }
3735 if self.condition.is_some() {
3736 len += 1;
3737 }
3738 if self.left_table.is_some() {
3739 len += 1;
3740 }
3741 if self.right_table.is_some() {
3742 len += 1;
3743 }
3744 if self.condition_always_relax {
3745 len += 1;
3746 }
3747 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
3748 if self.left_key != 0 {
3749 struct_ser.serialize_field("leftKey", &self.left_key)?;
3750 }
3751 if let Some(v) = self.condition.as_ref() {
3752 struct_ser.serialize_field("condition", v)?;
3753 }
3754 if let Some(v) = self.left_table.as_ref() {
3755 struct_ser.serialize_field("leftTable", v)?;
3756 }
3757 if let Some(v) = self.right_table.as_ref() {
3758 struct_ser.serialize_field("rightTable", v)?;
3759 }
3760 if self.condition_always_relax {
3761 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
3762 }
3763 struct_ser.end()
3764 }
3765}
3766impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
3767 #[allow(deprecated)]
3768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3769 where
3770 D: serde::Deserializer<'de>,
3771 {
3772 const FIELDS: &[&str] = &[
3773 "left_key",
3774 "leftKey",
3775 "condition",
3776 "left_table",
3777 "leftTable",
3778 "right_table",
3779 "rightTable",
3780 "condition_always_relax",
3781 "conditionAlwaysRelax",
3782 ];
3783
3784 #[allow(clippy::enum_variant_names)]
3785 enum GeneratedField {
3786 LeftKey,
3787 Condition,
3788 LeftTable,
3789 RightTable,
3790 ConditionAlwaysRelax,
3791 }
3792 impl<'de> serde::Deserialize<'de> for GeneratedField {
3793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3794 where
3795 D: serde::Deserializer<'de>,
3796 {
3797 struct GeneratedVisitor;
3798
3799 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3800 type Value = GeneratedField;
3801
3802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3803 write!(formatter, "expected one of: {:?}", &FIELDS)
3804 }
3805
3806 #[allow(unused_variables)]
3807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3808 where
3809 E: serde::de::Error,
3810 {
3811 match value {
3812 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3813 "condition" => Ok(GeneratedField::Condition),
3814 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
3815 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
3816 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
3817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3818 }
3819 }
3820 }
3821 deserializer.deserialize_identifier(GeneratedVisitor)
3822 }
3823 }
3824 struct GeneratedVisitor;
3825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3826 type Value = DynamicFilterNode;
3827
3828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3829 formatter.write_str("struct stream_plan.DynamicFilterNode")
3830 }
3831
3832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
3833 where
3834 V: serde::de::MapAccess<'de>,
3835 {
3836 let mut left_key__ = None;
3837 let mut condition__ = None;
3838 let mut left_table__ = None;
3839 let mut right_table__ = None;
3840 let mut condition_always_relax__ = None;
3841 while let Some(k) = map_.next_key()? {
3842 match k {
3843 GeneratedField::LeftKey => {
3844 if left_key__.is_some() {
3845 return Err(serde::de::Error::duplicate_field("leftKey"));
3846 }
3847 left_key__ =
3848 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3849 ;
3850 }
3851 GeneratedField::Condition => {
3852 if condition__.is_some() {
3853 return Err(serde::de::Error::duplicate_field("condition"));
3854 }
3855 condition__ = map_.next_value()?;
3856 }
3857 GeneratedField::LeftTable => {
3858 if left_table__.is_some() {
3859 return Err(serde::de::Error::duplicate_field("leftTable"));
3860 }
3861 left_table__ = map_.next_value()?;
3862 }
3863 GeneratedField::RightTable => {
3864 if right_table__.is_some() {
3865 return Err(serde::de::Error::duplicate_field("rightTable"));
3866 }
3867 right_table__ = map_.next_value()?;
3868 }
3869 GeneratedField::ConditionAlwaysRelax => {
3870 if condition_always_relax__.is_some() {
3871 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
3872 }
3873 condition_always_relax__ = Some(map_.next_value()?);
3874 }
3875 }
3876 }
3877 Ok(DynamicFilterNode {
3878 left_key: left_key__.unwrap_or_default(),
3879 condition: condition__,
3880 left_table: left_table__,
3881 right_table: right_table__,
3882 condition_always_relax: condition_always_relax__.unwrap_or_default(),
3883 })
3884 }
3885 }
3886 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
3887 }
3888}
3889impl serde::Serialize for EowcOverWindowNode {
3890 #[allow(deprecated)]
3891 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3892 where
3893 S: serde::Serializer,
3894 {
3895 use serde::ser::SerializeStruct;
3896 let mut len = 0;
3897 if !self.calls.is_empty() {
3898 len += 1;
3899 }
3900 if !self.partition_by.is_empty() {
3901 len += 1;
3902 }
3903 if !self.order_by.is_empty() {
3904 len += 1;
3905 }
3906 if self.state_table.is_some() {
3907 len += 1;
3908 }
3909 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
3910 if !self.calls.is_empty() {
3911 struct_ser.serialize_field("calls", &self.calls)?;
3912 }
3913 if !self.partition_by.is_empty() {
3914 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
3915 }
3916 if !self.order_by.is_empty() {
3917 struct_ser.serialize_field("orderBy", &self.order_by)?;
3918 }
3919 if let Some(v) = self.state_table.as_ref() {
3920 struct_ser.serialize_field("stateTable", v)?;
3921 }
3922 struct_ser.end()
3923 }
3924}
3925impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
3926 #[allow(deprecated)]
3927 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3928 where
3929 D: serde::Deserializer<'de>,
3930 {
3931 const FIELDS: &[&str] = &[
3932 "calls",
3933 "partition_by",
3934 "partitionBy",
3935 "order_by",
3936 "orderBy",
3937 "state_table",
3938 "stateTable",
3939 ];
3940
3941 #[allow(clippy::enum_variant_names)]
3942 enum GeneratedField {
3943 Calls,
3944 PartitionBy,
3945 OrderBy,
3946 StateTable,
3947 }
3948 impl<'de> serde::Deserialize<'de> for GeneratedField {
3949 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3950 where
3951 D: serde::Deserializer<'de>,
3952 {
3953 struct GeneratedVisitor;
3954
3955 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3956 type Value = GeneratedField;
3957
3958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3959 write!(formatter, "expected one of: {:?}", &FIELDS)
3960 }
3961
3962 #[allow(unused_variables)]
3963 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3964 where
3965 E: serde::de::Error,
3966 {
3967 match value {
3968 "calls" => Ok(GeneratedField::Calls),
3969 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
3970 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
3971 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
3972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3973 }
3974 }
3975 }
3976 deserializer.deserialize_identifier(GeneratedVisitor)
3977 }
3978 }
3979 struct GeneratedVisitor;
3980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3981 type Value = EowcOverWindowNode;
3982
3983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3984 formatter.write_str("struct stream_plan.EowcOverWindowNode")
3985 }
3986
3987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
3988 where
3989 V: serde::de::MapAccess<'de>,
3990 {
3991 let mut calls__ = None;
3992 let mut partition_by__ = None;
3993 let mut order_by__ = None;
3994 let mut state_table__ = None;
3995 while let Some(k) = map_.next_key()? {
3996 match k {
3997 GeneratedField::Calls => {
3998 if calls__.is_some() {
3999 return Err(serde::de::Error::duplicate_field("calls"));
4000 }
4001 calls__ = Some(map_.next_value()?);
4002 }
4003 GeneratedField::PartitionBy => {
4004 if partition_by__.is_some() {
4005 return Err(serde::de::Error::duplicate_field("partitionBy"));
4006 }
4007 partition_by__ =
4008 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4009 .into_iter().map(|x| x.0).collect())
4010 ;
4011 }
4012 GeneratedField::OrderBy => {
4013 if order_by__.is_some() {
4014 return Err(serde::de::Error::duplicate_field("orderBy"));
4015 }
4016 order_by__ = Some(map_.next_value()?);
4017 }
4018 GeneratedField::StateTable => {
4019 if state_table__.is_some() {
4020 return Err(serde::de::Error::duplicate_field("stateTable"));
4021 }
4022 state_table__ = map_.next_value()?;
4023 }
4024 }
4025 }
4026 Ok(EowcOverWindowNode {
4027 calls: calls__.unwrap_or_default(),
4028 partition_by: partition_by__.unwrap_or_default(),
4029 order_by: order_by__.unwrap_or_default(),
4030 state_table: state_table__,
4031 })
4032 }
4033 }
4034 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4035 }
4036}
4037impl serde::Serialize for ExchangeNode {
4038 #[allow(deprecated)]
4039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4040 where
4041 S: serde::Serializer,
4042 {
4043 use serde::ser::SerializeStruct;
4044 let mut len = 0;
4045 if self.strategy.is_some() {
4046 len += 1;
4047 }
4048 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4049 if let Some(v) = self.strategy.as_ref() {
4050 struct_ser.serialize_field("strategy", v)?;
4051 }
4052 struct_ser.end()
4053 }
4054}
4055impl<'de> serde::Deserialize<'de> for ExchangeNode {
4056 #[allow(deprecated)]
4057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4058 where
4059 D: serde::Deserializer<'de>,
4060 {
4061 const FIELDS: &[&str] = &[
4062 "strategy",
4063 ];
4064
4065 #[allow(clippy::enum_variant_names)]
4066 enum GeneratedField {
4067 Strategy,
4068 }
4069 impl<'de> serde::Deserialize<'de> for GeneratedField {
4070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4071 where
4072 D: serde::Deserializer<'de>,
4073 {
4074 struct GeneratedVisitor;
4075
4076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4077 type Value = GeneratedField;
4078
4079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4080 write!(formatter, "expected one of: {:?}", &FIELDS)
4081 }
4082
4083 #[allow(unused_variables)]
4084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4085 where
4086 E: serde::de::Error,
4087 {
4088 match value {
4089 "strategy" => Ok(GeneratedField::Strategy),
4090 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4091 }
4092 }
4093 }
4094 deserializer.deserialize_identifier(GeneratedVisitor)
4095 }
4096 }
4097 struct GeneratedVisitor;
4098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4099 type Value = ExchangeNode;
4100
4101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4102 formatter.write_str("struct stream_plan.ExchangeNode")
4103 }
4104
4105 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4106 where
4107 V: serde::de::MapAccess<'de>,
4108 {
4109 let mut strategy__ = None;
4110 while let Some(k) = map_.next_key()? {
4111 match k {
4112 GeneratedField::Strategy => {
4113 if strategy__.is_some() {
4114 return Err(serde::de::Error::duplicate_field("strategy"));
4115 }
4116 strategy__ = map_.next_value()?;
4117 }
4118 }
4119 }
4120 Ok(ExchangeNode {
4121 strategy: strategy__,
4122 })
4123 }
4124 }
4125 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4126 }
4127}
4128impl serde::Serialize for ExpandNode {
4129 #[allow(deprecated)]
4130 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4131 where
4132 S: serde::Serializer,
4133 {
4134 use serde::ser::SerializeStruct;
4135 let mut len = 0;
4136 if !self.column_subsets.is_empty() {
4137 len += 1;
4138 }
4139 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4140 if !self.column_subsets.is_empty() {
4141 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4142 }
4143 struct_ser.end()
4144 }
4145}
4146impl<'de> serde::Deserialize<'de> for ExpandNode {
4147 #[allow(deprecated)]
4148 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4149 where
4150 D: serde::Deserializer<'de>,
4151 {
4152 const FIELDS: &[&str] = &[
4153 "column_subsets",
4154 "columnSubsets",
4155 ];
4156
4157 #[allow(clippy::enum_variant_names)]
4158 enum GeneratedField {
4159 ColumnSubsets,
4160 }
4161 impl<'de> serde::Deserialize<'de> for GeneratedField {
4162 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4163 where
4164 D: serde::Deserializer<'de>,
4165 {
4166 struct GeneratedVisitor;
4167
4168 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4169 type Value = GeneratedField;
4170
4171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4172 write!(formatter, "expected one of: {:?}", &FIELDS)
4173 }
4174
4175 #[allow(unused_variables)]
4176 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4177 where
4178 E: serde::de::Error,
4179 {
4180 match value {
4181 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4183 }
4184 }
4185 }
4186 deserializer.deserialize_identifier(GeneratedVisitor)
4187 }
4188 }
4189 struct GeneratedVisitor;
4190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4191 type Value = ExpandNode;
4192
4193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4194 formatter.write_str("struct stream_plan.ExpandNode")
4195 }
4196
4197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4198 where
4199 V: serde::de::MapAccess<'de>,
4200 {
4201 let mut column_subsets__ = None;
4202 while let Some(k) = map_.next_key()? {
4203 match k {
4204 GeneratedField::ColumnSubsets => {
4205 if column_subsets__.is_some() {
4206 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4207 }
4208 column_subsets__ = Some(map_.next_value()?);
4209 }
4210 }
4211 }
4212 Ok(ExpandNode {
4213 column_subsets: column_subsets__.unwrap_or_default(),
4214 })
4215 }
4216 }
4217 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4218 }
4219}
4220impl serde::Serialize for expand_node::Subset {
4221 #[allow(deprecated)]
4222 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4223 where
4224 S: serde::Serializer,
4225 {
4226 use serde::ser::SerializeStruct;
4227 let mut len = 0;
4228 if !self.column_indices.is_empty() {
4229 len += 1;
4230 }
4231 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4232 if !self.column_indices.is_empty() {
4233 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4234 }
4235 struct_ser.end()
4236 }
4237}
4238impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4239 #[allow(deprecated)]
4240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4241 where
4242 D: serde::Deserializer<'de>,
4243 {
4244 const FIELDS: &[&str] = &[
4245 "column_indices",
4246 "columnIndices",
4247 ];
4248
4249 #[allow(clippy::enum_variant_names)]
4250 enum GeneratedField {
4251 ColumnIndices,
4252 }
4253 impl<'de> serde::Deserialize<'de> for GeneratedField {
4254 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4255 where
4256 D: serde::Deserializer<'de>,
4257 {
4258 struct GeneratedVisitor;
4259
4260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4261 type Value = GeneratedField;
4262
4263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4264 write!(formatter, "expected one of: {:?}", &FIELDS)
4265 }
4266
4267 #[allow(unused_variables)]
4268 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4269 where
4270 E: serde::de::Error,
4271 {
4272 match value {
4273 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4274 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4275 }
4276 }
4277 }
4278 deserializer.deserialize_identifier(GeneratedVisitor)
4279 }
4280 }
4281 struct GeneratedVisitor;
4282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4283 type Value = expand_node::Subset;
4284
4285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4286 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4287 }
4288
4289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4290 where
4291 V: serde::de::MapAccess<'de>,
4292 {
4293 let mut column_indices__ = None;
4294 while let Some(k) = map_.next_key()? {
4295 match k {
4296 GeneratedField::ColumnIndices => {
4297 if column_indices__.is_some() {
4298 return Err(serde::de::Error::duplicate_field("columnIndices"));
4299 }
4300 column_indices__ =
4301 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4302 .into_iter().map(|x| x.0).collect())
4303 ;
4304 }
4305 }
4306 }
4307 Ok(expand_node::Subset {
4308 column_indices: column_indices__.unwrap_or_default(),
4309 })
4310 }
4311 }
4312 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4313 }
4314}
4315impl serde::Serialize for FilterNode {
4316 #[allow(deprecated)]
4317 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4318 where
4319 S: serde::Serializer,
4320 {
4321 use serde::ser::SerializeStruct;
4322 let mut len = 0;
4323 if self.search_condition.is_some() {
4324 len += 1;
4325 }
4326 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4327 if let Some(v) = self.search_condition.as_ref() {
4328 struct_ser.serialize_field("searchCondition", v)?;
4329 }
4330 struct_ser.end()
4331 }
4332}
4333impl<'de> serde::Deserialize<'de> for FilterNode {
4334 #[allow(deprecated)]
4335 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4336 where
4337 D: serde::Deserializer<'de>,
4338 {
4339 const FIELDS: &[&str] = &[
4340 "search_condition",
4341 "searchCondition",
4342 ];
4343
4344 #[allow(clippy::enum_variant_names)]
4345 enum GeneratedField {
4346 SearchCondition,
4347 }
4348 impl<'de> serde::Deserialize<'de> for GeneratedField {
4349 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4350 where
4351 D: serde::Deserializer<'de>,
4352 {
4353 struct GeneratedVisitor;
4354
4355 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4356 type Value = GeneratedField;
4357
4358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4359 write!(formatter, "expected one of: {:?}", &FIELDS)
4360 }
4361
4362 #[allow(unused_variables)]
4363 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4364 where
4365 E: serde::de::Error,
4366 {
4367 match value {
4368 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4369 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4370 }
4371 }
4372 }
4373 deserializer.deserialize_identifier(GeneratedVisitor)
4374 }
4375 }
4376 struct GeneratedVisitor;
4377 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4378 type Value = FilterNode;
4379
4380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4381 formatter.write_str("struct stream_plan.FilterNode")
4382 }
4383
4384 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4385 where
4386 V: serde::de::MapAccess<'de>,
4387 {
4388 let mut search_condition__ = None;
4389 while let Some(k) = map_.next_key()? {
4390 match k {
4391 GeneratedField::SearchCondition => {
4392 if search_condition__.is_some() {
4393 return Err(serde::de::Error::duplicate_field("searchCondition"));
4394 }
4395 search_condition__ = map_.next_value()?;
4396 }
4397 }
4398 }
4399 Ok(FilterNode {
4400 search_condition: search_condition__,
4401 })
4402 }
4403 }
4404 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4405 }
4406}
4407impl serde::Serialize for FragmentTypeFlag {
4408 #[allow(deprecated)]
4409 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4410 where
4411 S: serde::Serializer,
4412 {
4413 let variant = match self {
4414 Self::FragmentUnspecified => "FRAGMENT_TYPE_FLAG_FRAGMENT_UNSPECIFIED",
4415 Self::Source => "FRAGMENT_TYPE_FLAG_SOURCE",
4416 Self::Mview => "FRAGMENT_TYPE_FLAG_MVIEW",
4417 Self::Sink => "FRAGMENT_TYPE_FLAG_SINK",
4418 Self::Now => "FRAGMENT_TYPE_FLAG_NOW",
4419 Self::StreamScan => "FRAGMENT_TYPE_FLAG_STREAM_SCAN",
4420 Self::BarrierRecv => "FRAGMENT_TYPE_FLAG_BARRIER_RECV",
4421 Self::Values => "FRAGMENT_TYPE_FLAG_VALUES",
4422 Self::Dml => "FRAGMENT_TYPE_FLAG_DML",
4423 Self::CdcFilter => "FRAGMENT_TYPE_FLAG_CDC_FILTER",
4424 Self::SourceScan => "FRAGMENT_TYPE_FLAG_SOURCE_SCAN",
4425 Self::SnapshotBackfillStreamScan => "FRAGMENT_TYPE_FLAG_SNAPSHOT_BACKFILL_STREAM_SCAN",
4426 Self::FsFetch => "FRAGMENT_TYPE_FLAG_FS_FETCH",
4427 Self::CrossDbSnapshotBackfillStreamScan => "FRAGMENT_TYPE_FLAG_CROSS_DB_SNAPSHOT_BACKFILL_STREAM_SCAN",
4428 };
4429 serializer.serialize_str(variant)
4430 }
4431}
4432impl<'de> serde::Deserialize<'de> for FragmentTypeFlag {
4433 #[allow(deprecated)]
4434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4435 where
4436 D: serde::Deserializer<'de>,
4437 {
4438 const FIELDS: &[&str] = &[
4439 "FRAGMENT_TYPE_FLAG_FRAGMENT_UNSPECIFIED",
4440 "FRAGMENT_TYPE_FLAG_SOURCE",
4441 "FRAGMENT_TYPE_FLAG_MVIEW",
4442 "FRAGMENT_TYPE_FLAG_SINK",
4443 "FRAGMENT_TYPE_FLAG_NOW",
4444 "FRAGMENT_TYPE_FLAG_STREAM_SCAN",
4445 "FRAGMENT_TYPE_FLAG_BARRIER_RECV",
4446 "FRAGMENT_TYPE_FLAG_VALUES",
4447 "FRAGMENT_TYPE_FLAG_DML",
4448 "FRAGMENT_TYPE_FLAG_CDC_FILTER",
4449 "FRAGMENT_TYPE_FLAG_SOURCE_SCAN",
4450 "FRAGMENT_TYPE_FLAG_SNAPSHOT_BACKFILL_STREAM_SCAN",
4451 "FRAGMENT_TYPE_FLAG_FS_FETCH",
4452 "FRAGMENT_TYPE_FLAG_CROSS_DB_SNAPSHOT_BACKFILL_STREAM_SCAN",
4453 ];
4454
4455 struct GeneratedVisitor;
4456
4457 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4458 type Value = FragmentTypeFlag;
4459
4460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4461 write!(formatter, "expected one of: {:?}", &FIELDS)
4462 }
4463
4464 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4465 where
4466 E: serde::de::Error,
4467 {
4468 i32::try_from(v)
4469 .ok()
4470 .and_then(|x| x.try_into().ok())
4471 .ok_or_else(|| {
4472 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4473 })
4474 }
4475
4476 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4477 where
4478 E: serde::de::Error,
4479 {
4480 i32::try_from(v)
4481 .ok()
4482 .and_then(|x| x.try_into().ok())
4483 .ok_or_else(|| {
4484 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4485 })
4486 }
4487
4488 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4489 where
4490 E: serde::de::Error,
4491 {
4492 match value {
4493 "FRAGMENT_TYPE_FLAG_FRAGMENT_UNSPECIFIED" => Ok(FragmentTypeFlag::FragmentUnspecified),
4494 "FRAGMENT_TYPE_FLAG_SOURCE" => Ok(FragmentTypeFlag::Source),
4495 "FRAGMENT_TYPE_FLAG_MVIEW" => Ok(FragmentTypeFlag::Mview),
4496 "FRAGMENT_TYPE_FLAG_SINK" => Ok(FragmentTypeFlag::Sink),
4497 "FRAGMENT_TYPE_FLAG_NOW" => Ok(FragmentTypeFlag::Now),
4498 "FRAGMENT_TYPE_FLAG_STREAM_SCAN" => Ok(FragmentTypeFlag::StreamScan),
4499 "FRAGMENT_TYPE_FLAG_BARRIER_RECV" => Ok(FragmentTypeFlag::BarrierRecv),
4500 "FRAGMENT_TYPE_FLAG_VALUES" => Ok(FragmentTypeFlag::Values),
4501 "FRAGMENT_TYPE_FLAG_DML" => Ok(FragmentTypeFlag::Dml),
4502 "FRAGMENT_TYPE_FLAG_CDC_FILTER" => Ok(FragmentTypeFlag::CdcFilter),
4503 "FRAGMENT_TYPE_FLAG_SOURCE_SCAN" => Ok(FragmentTypeFlag::SourceScan),
4504 "FRAGMENT_TYPE_FLAG_SNAPSHOT_BACKFILL_STREAM_SCAN" => Ok(FragmentTypeFlag::SnapshotBackfillStreamScan),
4505 "FRAGMENT_TYPE_FLAG_FS_FETCH" => Ok(FragmentTypeFlag::FsFetch),
4506 "FRAGMENT_TYPE_FLAG_CROSS_DB_SNAPSHOT_BACKFILL_STREAM_SCAN" => Ok(FragmentTypeFlag::CrossDbSnapshotBackfillStreamScan),
4507 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4508 }
4509 }
4510 }
4511 deserializer.deserialize_any(GeneratedVisitor)
4512 }
4513}
4514impl serde::Serialize for GlobalApproxPercentileNode {
4515 #[allow(deprecated)]
4516 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4517 where
4518 S: serde::Serializer,
4519 {
4520 use serde::ser::SerializeStruct;
4521 let mut len = 0;
4522 if self.base != 0. {
4523 len += 1;
4524 }
4525 if self.quantile != 0. {
4526 len += 1;
4527 }
4528 if self.bucket_state_table.is_some() {
4529 len += 1;
4530 }
4531 if self.count_state_table.is_some() {
4532 len += 1;
4533 }
4534 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4535 if self.base != 0. {
4536 struct_ser.serialize_field("base", &self.base)?;
4537 }
4538 if self.quantile != 0. {
4539 struct_ser.serialize_field("quantile", &self.quantile)?;
4540 }
4541 if let Some(v) = self.bucket_state_table.as_ref() {
4542 struct_ser.serialize_field("bucketStateTable", v)?;
4543 }
4544 if let Some(v) = self.count_state_table.as_ref() {
4545 struct_ser.serialize_field("countStateTable", v)?;
4546 }
4547 struct_ser.end()
4548 }
4549}
4550impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4551 #[allow(deprecated)]
4552 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4553 where
4554 D: serde::Deserializer<'de>,
4555 {
4556 const FIELDS: &[&str] = &[
4557 "base",
4558 "quantile",
4559 "bucket_state_table",
4560 "bucketStateTable",
4561 "count_state_table",
4562 "countStateTable",
4563 ];
4564
4565 #[allow(clippy::enum_variant_names)]
4566 enum GeneratedField {
4567 Base,
4568 Quantile,
4569 BucketStateTable,
4570 CountStateTable,
4571 }
4572 impl<'de> serde::Deserialize<'de> for GeneratedField {
4573 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4574 where
4575 D: serde::Deserializer<'de>,
4576 {
4577 struct GeneratedVisitor;
4578
4579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4580 type Value = GeneratedField;
4581
4582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4583 write!(formatter, "expected one of: {:?}", &FIELDS)
4584 }
4585
4586 #[allow(unused_variables)]
4587 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4588 where
4589 E: serde::de::Error,
4590 {
4591 match value {
4592 "base" => Ok(GeneratedField::Base),
4593 "quantile" => Ok(GeneratedField::Quantile),
4594 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4595 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4597 }
4598 }
4599 }
4600 deserializer.deserialize_identifier(GeneratedVisitor)
4601 }
4602 }
4603 struct GeneratedVisitor;
4604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4605 type Value = GlobalApproxPercentileNode;
4606
4607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4608 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4609 }
4610
4611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4612 where
4613 V: serde::de::MapAccess<'de>,
4614 {
4615 let mut base__ = None;
4616 let mut quantile__ = None;
4617 let mut bucket_state_table__ = None;
4618 let mut count_state_table__ = None;
4619 while let Some(k) = map_.next_key()? {
4620 match k {
4621 GeneratedField::Base => {
4622 if base__.is_some() {
4623 return Err(serde::de::Error::duplicate_field("base"));
4624 }
4625 base__ =
4626 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4627 ;
4628 }
4629 GeneratedField::Quantile => {
4630 if quantile__.is_some() {
4631 return Err(serde::de::Error::duplicate_field("quantile"));
4632 }
4633 quantile__ =
4634 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4635 ;
4636 }
4637 GeneratedField::BucketStateTable => {
4638 if bucket_state_table__.is_some() {
4639 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4640 }
4641 bucket_state_table__ = map_.next_value()?;
4642 }
4643 GeneratedField::CountStateTable => {
4644 if count_state_table__.is_some() {
4645 return Err(serde::de::Error::duplicate_field("countStateTable"));
4646 }
4647 count_state_table__ = map_.next_value()?;
4648 }
4649 }
4650 }
4651 Ok(GlobalApproxPercentileNode {
4652 base: base__.unwrap_or_default(),
4653 quantile: quantile__.unwrap_or_default(),
4654 bucket_state_table: bucket_state_table__,
4655 count_state_table: count_state_table__,
4656 })
4657 }
4658 }
4659 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4660 }
4661}
4662impl serde::Serialize for GroupTopNNode {
4663 #[allow(deprecated)]
4664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4665 where
4666 S: serde::Serializer,
4667 {
4668 use serde::ser::SerializeStruct;
4669 let mut len = 0;
4670 if self.limit != 0 {
4671 len += 1;
4672 }
4673 if self.offset != 0 {
4674 len += 1;
4675 }
4676 if !self.group_key.is_empty() {
4677 len += 1;
4678 }
4679 if self.table.is_some() {
4680 len += 1;
4681 }
4682 if !self.order_by.is_empty() {
4683 len += 1;
4684 }
4685 if self.with_ties {
4686 len += 1;
4687 }
4688 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
4689 if self.limit != 0 {
4690 #[allow(clippy::needless_borrow)]
4691 #[allow(clippy::needless_borrows_for_generic_args)]
4692 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
4693 }
4694 if self.offset != 0 {
4695 #[allow(clippy::needless_borrow)]
4696 #[allow(clippy::needless_borrows_for_generic_args)]
4697 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
4698 }
4699 if !self.group_key.is_empty() {
4700 struct_ser.serialize_field("groupKey", &self.group_key)?;
4701 }
4702 if let Some(v) = self.table.as_ref() {
4703 struct_ser.serialize_field("table", v)?;
4704 }
4705 if !self.order_by.is_empty() {
4706 struct_ser.serialize_field("orderBy", &self.order_by)?;
4707 }
4708 if self.with_ties {
4709 struct_ser.serialize_field("withTies", &self.with_ties)?;
4710 }
4711 struct_ser.end()
4712 }
4713}
4714impl<'de> serde::Deserialize<'de> for GroupTopNNode {
4715 #[allow(deprecated)]
4716 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4717 where
4718 D: serde::Deserializer<'de>,
4719 {
4720 const FIELDS: &[&str] = &[
4721 "limit",
4722 "offset",
4723 "group_key",
4724 "groupKey",
4725 "table",
4726 "order_by",
4727 "orderBy",
4728 "with_ties",
4729 "withTies",
4730 ];
4731
4732 #[allow(clippy::enum_variant_names)]
4733 enum GeneratedField {
4734 Limit,
4735 Offset,
4736 GroupKey,
4737 Table,
4738 OrderBy,
4739 WithTies,
4740 }
4741 impl<'de> serde::Deserialize<'de> for GeneratedField {
4742 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4743 where
4744 D: serde::Deserializer<'de>,
4745 {
4746 struct GeneratedVisitor;
4747
4748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4749 type Value = GeneratedField;
4750
4751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4752 write!(formatter, "expected one of: {:?}", &FIELDS)
4753 }
4754
4755 #[allow(unused_variables)]
4756 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4757 where
4758 E: serde::de::Error,
4759 {
4760 match value {
4761 "limit" => Ok(GeneratedField::Limit),
4762 "offset" => Ok(GeneratedField::Offset),
4763 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
4764 "table" => Ok(GeneratedField::Table),
4765 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4766 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
4767 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4768 }
4769 }
4770 }
4771 deserializer.deserialize_identifier(GeneratedVisitor)
4772 }
4773 }
4774 struct GeneratedVisitor;
4775 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4776 type Value = GroupTopNNode;
4777
4778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4779 formatter.write_str("struct stream_plan.GroupTopNNode")
4780 }
4781
4782 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
4783 where
4784 V: serde::de::MapAccess<'de>,
4785 {
4786 let mut limit__ = None;
4787 let mut offset__ = None;
4788 let mut group_key__ = None;
4789 let mut table__ = None;
4790 let mut order_by__ = None;
4791 let mut with_ties__ = None;
4792 while let Some(k) = map_.next_key()? {
4793 match k {
4794 GeneratedField::Limit => {
4795 if limit__.is_some() {
4796 return Err(serde::de::Error::duplicate_field("limit"));
4797 }
4798 limit__ =
4799 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4800 ;
4801 }
4802 GeneratedField::Offset => {
4803 if offset__.is_some() {
4804 return Err(serde::de::Error::duplicate_field("offset"));
4805 }
4806 offset__ =
4807 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4808 ;
4809 }
4810 GeneratedField::GroupKey => {
4811 if group_key__.is_some() {
4812 return Err(serde::de::Error::duplicate_field("groupKey"));
4813 }
4814 group_key__ =
4815 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4816 .into_iter().map(|x| x.0).collect())
4817 ;
4818 }
4819 GeneratedField::Table => {
4820 if table__.is_some() {
4821 return Err(serde::de::Error::duplicate_field("table"));
4822 }
4823 table__ = map_.next_value()?;
4824 }
4825 GeneratedField::OrderBy => {
4826 if order_by__.is_some() {
4827 return Err(serde::de::Error::duplicate_field("orderBy"));
4828 }
4829 order_by__ = Some(map_.next_value()?);
4830 }
4831 GeneratedField::WithTies => {
4832 if with_ties__.is_some() {
4833 return Err(serde::de::Error::duplicate_field("withTies"));
4834 }
4835 with_ties__ = Some(map_.next_value()?);
4836 }
4837 }
4838 }
4839 Ok(GroupTopNNode {
4840 limit: limit__.unwrap_or_default(),
4841 offset: offset__.unwrap_or_default(),
4842 group_key: group_key__.unwrap_or_default(),
4843 table: table__,
4844 order_by: order_by__.unwrap_or_default(),
4845 with_ties: with_ties__.unwrap_or_default(),
4846 })
4847 }
4848 }
4849 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
4850 }
4851}
4852impl serde::Serialize for HashAggNode {
4853 #[allow(deprecated)]
4854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4855 where
4856 S: serde::Serializer,
4857 {
4858 use serde::ser::SerializeStruct;
4859 let mut len = 0;
4860 if !self.group_key.is_empty() {
4861 len += 1;
4862 }
4863 if !self.agg_calls.is_empty() {
4864 len += 1;
4865 }
4866 if !self.agg_call_states.is_empty() {
4867 len += 1;
4868 }
4869 if self.intermediate_state_table.is_some() {
4870 len += 1;
4871 }
4872 if self.is_append_only {
4873 len += 1;
4874 }
4875 if !self.distinct_dedup_tables.is_empty() {
4876 len += 1;
4877 }
4878 if self.row_count_index != 0 {
4879 len += 1;
4880 }
4881 if self.emit_on_window_close {
4882 len += 1;
4883 }
4884 if self.version != 0 {
4885 len += 1;
4886 }
4887 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
4888 if !self.group_key.is_empty() {
4889 struct_ser.serialize_field("groupKey", &self.group_key)?;
4890 }
4891 if !self.agg_calls.is_empty() {
4892 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
4893 }
4894 if !self.agg_call_states.is_empty() {
4895 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
4896 }
4897 if let Some(v) = self.intermediate_state_table.as_ref() {
4898 struct_ser.serialize_field("intermediateStateTable", v)?;
4899 }
4900 if self.is_append_only {
4901 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
4902 }
4903 if !self.distinct_dedup_tables.is_empty() {
4904 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
4905 }
4906 if self.row_count_index != 0 {
4907 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
4908 }
4909 if self.emit_on_window_close {
4910 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
4911 }
4912 if self.version != 0 {
4913 let v = AggNodeVersion::try_from(self.version)
4914 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4915 struct_ser.serialize_field("version", &v)?;
4916 }
4917 struct_ser.end()
4918 }
4919}
4920impl<'de> serde::Deserialize<'de> for HashAggNode {
4921 #[allow(deprecated)]
4922 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4923 where
4924 D: serde::Deserializer<'de>,
4925 {
4926 const FIELDS: &[&str] = &[
4927 "group_key",
4928 "groupKey",
4929 "agg_calls",
4930 "aggCalls",
4931 "agg_call_states",
4932 "aggCallStates",
4933 "intermediate_state_table",
4934 "intermediateStateTable",
4935 "is_append_only",
4936 "isAppendOnly",
4937 "distinct_dedup_tables",
4938 "distinctDedupTables",
4939 "row_count_index",
4940 "rowCountIndex",
4941 "emit_on_window_close",
4942 "emitOnWindowClose",
4943 "version",
4944 ];
4945
4946 #[allow(clippy::enum_variant_names)]
4947 enum GeneratedField {
4948 GroupKey,
4949 AggCalls,
4950 AggCallStates,
4951 IntermediateStateTable,
4952 IsAppendOnly,
4953 DistinctDedupTables,
4954 RowCountIndex,
4955 EmitOnWindowClose,
4956 Version,
4957 }
4958 impl<'de> serde::Deserialize<'de> for GeneratedField {
4959 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4960 where
4961 D: serde::Deserializer<'de>,
4962 {
4963 struct GeneratedVisitor;
4964
4965 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4966 type Value = GeneratedField;
4967
4968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4969 write!(formatter, "expected one of: {:?}", &FIELDS)
4970 }
4971
4972 #[allow(unused_variables)]
4973 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4974 where
4975 E: serde::de::Error,
4976 {
4977 match value {
4978 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
4979 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
4980 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
4981 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
4982 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
4983 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
4984 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
4985 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
4986 "version" => Ok(GeneratedField::Version),
4987 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4988 }
4989 }
4990 }
4991 deserializer.deserialize_identifier(GeneratedVisitor)
4992 }
4993 }
4994 struct GeneratedVisitor;
4995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4996 type Value = HashAggNode;
4997
4998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4999 formatter.write_str("struct stream_plan.HashAggNode")
5000 }
5001
5002 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5003 where
5004 V: serde::de::MapAccess<'de>,
5005 {
5006 let mut group_key__ = None;
5007 let mut agg_calls__ = None;
5008 let mut agg_call_states__ = None;
5009 let mut intermediate_state_table__ = None;
5010 let mut is_append_only__ = None;
5011 let mut distinct_dedup_tables__ = None;
5012 let mut row_count_index__ = None;
5013 let mut emit_on_window_close__ = None;
5014 let mut version__ = None;
5015 while let Some(k) = map_.next_key()? {
5016 match k {
5017 GeneratedField::GroupKey => {
5018 if group_key__.is_some() {
5019 return Err(serde::de::Error::duplicate_field("groupKey"));
5020 }
5021 group_key__ =
5022 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5023 .into_iter().map(|x| x.0).collect())
5024 ;
5025 }
5026 GeneratedField::AggCalls => {
5027 if agg_calls__.is_some() {
5028 return Err(serde::de::Error::duplicate_field("aggCalls"));
5029 }
5030 agg_calls__ = Some(map_.next_value()?);
5031 }
5032 GeneratedField::AggCallStates => {
5033 if agg_call_states__.is_some() {
5034 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5035 }
5036 agg_call_states__ = Some(map_.next_value()?);
5037 }
5038 GeneratedField::IntermediateStateTable => {
5039 if intermediate_state_table__.is_some() {
5040 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5041 }
5042 intermediate_state_table__ = map_.next_value()?;
5043 }
5044 GeneratedField::IsAppendOnly => {
5045 if is_append_only__.is_some() {
5046 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5047 }
5048 is_append_only__ = Some(map_.next_value()?);
5049 }
5050 GeneratedField::DistinctDedupTables => {
5051 if distinct_dedup_tables__.is_some() {
5052 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5053 }
5054 distinct_dedup_tables__ = Some(
5055 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5056 .into_iter().map(|(k,v)| (k.0, v)).collect()
5057 );
5058 }
5059 GeneratedField::RowCountIndex => {
5060 if row_count_index__.is_some() {
5061 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5062 }
5063 row_count_index__ =
5064 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5065 ;
5066 }
5067 GeneratedField::EmitOnWindowClose => {
5068 if emit_on_window_close__.is_some() {
5069 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5070 }
5071 emit_on_window_close__ = Some(map_.next_value()?);
5072 }
5073 GeneratedField::Version => {
5074 if version__.is_some() {
5075 return Err(serde::de::Error::duplicate_field("version"));
5076 }
5077 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5078 }
5079 }
5080 }
5081 Ok(HashAggNode {
5082 group_key: group_key__.unwrap_or_default(),
5083 agg_calls: agg_calls__.unwrap_or_default(),
5084 agg_call_states: agg_call_states__.unwrap_or_default(),
5085 intermediate_state_table: intermediate_state_table__,
5086 is_append_only: is_append_only__.unwrap_or_default(),
5087 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5088 row_count_index: row_count_index__.unwrap_or_default(),
5089 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5090 version: version__.unwrap_or_default(),
5091 })
5092 }
5093 }
5094 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5095 }
5096}
5097impl serde::Serialize for HashJoinNode {
5098 #[allow(deprecated)]
5099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5100 where
5101 S: serde::Serializer,
5102 {
5103 use serde::ser::SerializeStruct;
5104 let mut len = 0;
5105 if self.join_type != 0 {
5106 len += 1;
5107 }
5108 if !self.left_key.is_empty() {
5109 len += 1;
5110 }
5111 if !self.right_key.is_empty() {
5112 len += 1;
5113 }
5114 if self.condition.is_some() {
5115 len += 1;
5116 }
5117 if !self.inequality_pairs.is_empty() {
5118 len += 1;
5119 }
5120 if self.left_table.is_some() {
5121 len += 1;
5122 }
5123 if self.right_table.is_some() {
5124 len += 1;
5125 }
5126 if self.left_degree_table.is_some() {
5127 len += 1;
5128 }
5129 if self.right_degree_table.is_some() {
5130 len += 1;
5131 }
5132 if !self.output_indices.is_empty() {
5133 len += 1;
5134 }
5135 if !self.left_deduped_input_pk_indices.is_empty() {
5136 len += 1;
5137 }
5138 if !self.right_deduped_input_pk_indices.is_empty() {
5139 len += 1;
5140 }
5141 if !self.null_safe.is_empty() {
5142 len += 1;
5143 }
5144 if self.is_append_only {
5145 len += 1;
5146 }
5147 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5148 if self.join_type != 0 {
5149 let v = super::plan_common::JoinType::try_from(self.join_type)
5150 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5151 struct_ser.serialize_field("joinType", &v)?;
5152 }
5153 if !self.left_key.is_empty() {
5154 struct_ser.serialize_field("leftKey", &self.left_key)?;
5155 }
5156 if !self.right_key.is_empty() {
5157 struct_ser.serialize_field("rightKey", &self.right_key)?;
5158 }
5159 if let Some(v) = self.condition.as_ref() {
5160 struct_ser.serialize_field("condition", v)?;
5161 }
5162 if !self.inequality_pairs.is_empty() {
5163 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5164 }
5165 if let Some(v) = self.left_table.as_ref() {
5166 struct_ser.serialize_field("leftTable", v)?;
5167 }
5168 if let Some(v) = self.right_table.as_ref() {
5169 struct_ser.serialize_field("rightTable", v)?;
5170 }
5171 if let Some(v) = self.left_degree_table.as_ref() {
5172 struct_ser.serialize_field("leftDegreeTable", v)?;
5173 }
5174 if let Some(v) = self.right_degree_table.as_ref() {
5175 struct_ser.serialize_field("rightDegreeTable", v)?;
5176 }
5177 if !self.output_indices.is_empty() {
5178 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5179 }
5180 if !self.left_deduped_input_pk_indices.is_empty() {
5181 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5182 }
5183 if !self.right_deduped_input_pk_indices.is_empty() {
5184 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5185 }
5186 if !self.null_safe.is_empty() {
5187 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5188 }
5189 if self.is_append_only {
5190 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5191 }
5192 struct_ser.end()
5193 }
5194}
5195impl<'de> serde::Deserialize<'de> for HashJoinNode {
5196 #[allow(deprecated)]
5197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5198 where
5199 D: serde::Deserializer<'de>,
5200 {
5201 const FIELDS: &[&str] = &[
5202 "join_type",
5203 "joinType",
5204 "left_key",
5205 "leftKey",
5206 "right_key",
5207 "rightKey",
5208 "condition",
5209 "inequality_pairs",
5210 "inequalityPairs",
5211 "left_table",
5212 "leftTable",
5213 "right_table",
5214 "rightTable",
5215 "left_degree_table",
5216 "leftDegreeTable",
5217 "right_degree_table",
5218 "rightDegreeTable",
5219 "output_indices",
5220 "outputIndices",
5221 "left_deduped_input_pk_indices",
5222 "leftDedupedInputPkIndices",
5223 "right_deduped_input_pk_indices",
5224 "rightDedupedInputPkIndices",
5225 "null_safe",
5226 "nullSafe",
5227 "is_append_only",
5228 "isAppendOnly",
5229 ];
5230
5231 #[allow(clippy::enum_variant_names)]
5232 enum GeneratedField {
5233 JoinType,
5234 LeftKey,
5235 RightKey,
5236 Condition,
5237 InequalityPairs,
5238 LeftTable,
5239 RightTable,
5240 LeftDegreeTable,
5241 RightDegreeTable,
5242 OutputIndices,
5243 LeftDedupedInputPkIndices,
5244 RightDedupedInputPkIndices,
5245 NullSafe,
5246 IsAppendOnly,
5247 }
5248 impl<'de> serde::Deserialize<'de> for GeneratedField {
5249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5250 where
5251 D: serde::Deserializer<'de>,
5252 {
5253 struct GeneratedVisitor;
5254
5255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5256 type Value = GeneratedField;
5257
5258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5259 write!(formatter, "expected one of: {:?}", &FIELDS)
5260 }
5261
5262 #[allow(unused_variables)]
5263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5264 where
5265 E: serde::de::Error,
5266 {
5267 match value {
5268 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5269 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5270 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5271 "condition" => Ok(GeneratedField::Condition),
5272 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5273 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5274 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5275 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5276 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5277 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5278 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5279 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5280 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5281 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5283 }
5284 }
5285 }
5286 deserializer.deserialize_identifier(GeneratedVisitor)
5287 }
5288 }
5289 struct GeneratedVisitor;
5290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5291 type Value = HashJoinNode;
5292
5293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5294 formatter.write_str("struct stream_plan.HashJoinNode")
5295 }
5296
5297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5298 where
5299 V: serde::de::MapAccess<'de>,
5300 {
5301 let mut join_type__ = None;
5302 let mut left_key__ = None;
5303 let mut right_key__ = None;
5304 let mut condition__ = None;
5305 let mut inequality_pairs__ = None;
5306 let mut left_table__ = None;
5307 let mut right_table__ = None;
5308 let mut left_degree_table__ = None;
5309 let mut right_degree_table__ = None;
5310 let mut output_indices__ = None;
5311 let mut left_deduped_input_pk_indices__ = None;
5312 let mut right_deduped_input_pk_indices__ = None;
5313 let mut null_safe__ = None;
5314 let mut is_append_only__ = None;
5315 while let Some(k) = map_.next_key()? {
5316 match k {
5317 GeneratedField::JoinType => {
5318 if join_type__.is_some() {
5319 return Err(serde::de::Error::duplicate_field("joinType"));
5320 }
5321 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5322 }
5323 GeneratedField::LeftKey => {
5324 if left_key__.is_some() {
5325 return Err(serde::de::Error::duplicate_field("leftKey"));
5326 }
5327 left_key__ =
5328 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5329 .into_iter().map(|x| x.0).collect())
5330 ;
5331 }
5332 GeneratedField::RightKey => {
5333 if right_key__.is_some() {
5334 return Err(serde::de::Error::duplicate_field("rightKey"));
5335 }
5336 right_key__ =
5337 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5338 .into_iter().map(|x| x.0).collect())
5339 ;
5340 }
5341 GeneratedField::Condition => {
5342 if condition__.is_some() {
5343 return Err(serde::de::Error::duplicate_field("condition"));
5344 }
5345 condition__ = map_.next_value()?;
5346 }
5347 GeneratedField::InequalityPairs => {
5348 if inequality_pairs__.is_some() {
5349 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5350 }
5351 inequality_pairs__ = Some(map_.next_value()?);
5352 }
5353 GeneratedField::LeftTable => {
5354 if left_table__.is_some() {
5355 return Err(serde::de::Error::duplicate_field("leftTable"));
5356 }
5357 left_table__ = map_.next_value()?;
5358 }
5359 GeneratedField::RightTable => {
5360 if right_table__.is_some() {
5361 return Err(serde::de::Error::duplicate_field("rightTable"));
5362 }
5363 right_table__ = map_.next_value()?;
5364 }
5365 GeneratedField::LeftDegreeTable => {
5366 if left_degree_table__.is_some() {
5367 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5368 }
5369 left_degree_table__ = map_.next_value()?;
5370 }
5371 GeneratedField::RightDegreeTable => {
5372 if right_degree_table__.is_some() {
5373 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5374 }
5375 right_degree_table__ = map_.next_value()?;
5376 }
5377 GeneratedField::OutputIndices => {
5378 if output_indices__.is_some() {
5379 return Err(serde::de::Error::duplicate_field("outputIndices"));
5380 }
5381 output_indices__ =
5382 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5383 .into_iter().map(|x| x.0).collect())
5384 ;
5385 }
5386 GeneratedField::LeftDedupedInputPkIndices => {
5387 if left_deduped_input_pk_indices__.is_some() {
5388 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5389 }
5390 left_deduped_input_pk_indices__ =
5391 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5392 .into_iter().map(|x| x.0).collect())
5393 ;
5394 }
5395 GeneratedField::RightDedupedInputPkIndices => {
5396 if right_deduped_input_pk_indices__.is_some() {
5397 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5398 }
5399 right_deduped_input_pk_indices__ =
5400 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5401 .into_iter().map(|x| x.0).collect())
5402 ;
5403 }
5404 GeneratedField::NullSafe => {
5405 if null_safe__.is_some() {
5406 return Err(serde::de::Error::duplicate_field("nullSafe"));
5407 }
5408 null_safe__ = Some(map_.next_value()?);
5409 }
5410 GeneratedField::IsAppendOnly => {
5411 if is_append_only__.is_some() {
5412 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5413 }
5414 is_append_only__ = Some(map_.next_value()?);
5415 }
5416 }
5417 }
5418 Ok(HashJoinNode {
5419 join_type: join_type__.unwrap_or_default(),
5420 left_key: left_key__.unwrap_or_default(),
5421 right_key: right_key__.unwrap_or_default(),
5422 condition: condition__,
5423 inequality_pairs: inequality_pairs__.unwrap_or_default(),
5424 left_table: left_table__,
5425 right_table: right_table__,
5426 left_degree_table: left_degree_table__,
5427 right_degree_table: right_degree_table__,
5428 output_indices: output_indices__.unwrap_or_default(),
5429 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5430 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5431 null_safe: null_safe__.unwrap_or_default(),
5432 is_append_only: is_append_only__.unwrap_or_default(),
5433 })
5434 }
5435 }
5436 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5437 }
5438}
5439impl serde::Serialize for HopWindowNode {
5440 #[allow(deprecated)]
5441 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5442 where
5443 S: serde::Serializer,
5444 {
5445 use serde::ser::SerializeStruct;
5446 let mut len = 0;
5447 if self.time_col != 0 {
5448 len += 1;
5449 }
5450 if self.window_slide.is_some() {
5451 len += 1;
5452 }
5453 if self.window_size.is_some() {
5454 len += 1;
5455 }
5456 if !self.output_indices.is_empty() {
5457 len += 1;
5458 }
5459 if !self.window_start_exprs.is_empty() {
5460 len += 1;
5461 }
5462 if !self.window_end_exprs.is_empty() {
5463 len += 1;
5464 }
5465 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5466 if self.time_col != 0 {
5467 struct_ser.serialize_field("timeCol", &self.time_col)?;
5468 }
5469 if let Some(v) = self.window_slide.as_ref() {
5470 struct_ser.serialize_field("windowSlide", v)?;
5471 }
5472 if let Some(v) = self.window_size.as_ref() {
5473 struct_ser.serialize_field("windowSize", v)?;
5474 }
5475 if !self.output_indices.is_empty() {
5476 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5477 }
5478 if !self.window_start_exprs.is_empty() {
5479 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5480 }
5481 if !self.window_end_exprs.is_empty() {
5482 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5483 }
5484 struct_ser.end()
5485 }
5486}
5487impl<'de> serde::Deserialize<'de> for HopWindowNode {
5488 #[allow(deprecated)]
5489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5490 where
5491 D: serde::Deserializer<'de>,
5492 {
5493 const FIELDS: &[&str] = &[
5494 "time_col",
5495 "timeCol",
5496 "window_slide",
5497 "windowSlide",
5498 "window_size",
5499 "windowSize",
5500 "output_indices",
5501 "outputIndices",
5502 "window_start_exprs",
5503 "windowStartExprs",
5504 "window_end_exprs",
5505 "windowEndExprs",
5506 ];
5507
5508 #[allow(clippy::enum_variant_names)]
5509 enum GeneratedField {
5510 TimeCol,
5511 WindowSlide,
5512 WindowSize,
5513 OutputIndices,
5514 WindowStartExprs,
5515 WindowEndExprs,
5516 }
5517 impl<'de> serde::Deserialize<'de> for GeneratedField {
5518 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5519 where
5520 D: serde::Deserializer<'de>,
5521 {
5522 struct GeneratedVisitor;
5523
5524 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5525 type Value = GeneratedField;
5526
5527 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5528 write!(formatter, "expected one of: {:?}", &FIELDS)
5529 }
5530
5531 #[allow(unused_variables)]
5532 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5533 where
5534 E: serde::de::Error,
5535 {
5536 match value {
5537 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5538 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5539 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5540 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5541 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5542 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5543 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5544 }
5545 }
5546 }
5547 deserializer.deserialize_identifier(GeneratedVisitor)
5548 }
5549 }
5550 struct GeneratedVisitor;
5551 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5552 type Value = HopWindowNode;
5553
5554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5555 formatter.write_str("struct stream_plan.HopWindowNode")
5556 }
5557
5558 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5559 where
5560 V: serde::de::MapAccess<'de>,
5561 {
5562 let mut time_col__ = None;
5563 let mut window_slide__ = None;
5564 let mut window_size__ = None;
5565 let mut output_indices__ = None;
5566 let mut window_start_exprs__ = None;
5567 let mut window_end_exprs__ = None;
5568 while let Some(k) = map_.next_key()? {
5569 match k {
5570 GeneratedField::TimeCol => {
5571 if time_col__.is_some() {
5572 return Err(serde::de::Error::duplicate_field("timeCol"));
5573 }
5574 time_col__ =
5575 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5576 ;
5577 }
5578 GeneratedField::WindowSlide => {
5579 if window_slide__.is_some() {
5580 return Err(serde::de::Error::duplicate_field("windowSlide"));
5581 }
5582 window_slide__ = map_.next_value()?;
5583 }
5584 GeneratedField::WindowSize => {
5585 if window_size__.is_some() {
5586 return Err(serde::de::Error::duplicate_field("windowSize"));
5587 }
5588 window_size__ = map_.next_value()?;
5589 }
5590 GeneratedField::OutputIndices => {
5591 if output_indices__.is_some() {
5592 return Err(serde::de::Error::duplicate_field("outputIndices"));
5593 }
5594 output_indices__ =
5595 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5596 .into_iter().map(|x| x.0).collect())
5597 ;
5598 }
5599 GeneratedField::WindowStartExprs => {
5600 if window_start_exprs__.is_some() {
5601 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5602 }
5603 window_start_exprs__ = Some(map_.next_value()?);
5604 }
5605 GeneratedField::WindowEndExprs => {
5606 if window_end_exprs__.is_some() {
5607 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5608 }
5609 window_end_exprs__ = Some(map_.next_value()?);
5610 }
5611 }
5612 }
5613 Ok(HopWindowNode {
5614 time_col: time_col__.unwrap_or_default(),
5615 window_slide: window_slide__,
5616 window_size: window_size__,
5617 output_indices: output_indices__.unwrap_or_default(),
5618 window_start_exprs: window_start_exprs__.unwrap_or_default(),
5619 window_end_exprs: window_end_exprs__.unwrap_or_default(),
5620 })
5621 }
5622 }
5623 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5624 }
5625}
5626impl serde::Serialize for InequalityPair {
5627 #[allow(deprecated)]
5628 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5629 where
5630 S: serde::Serializer,
5631 {
5632 use serde::ser::SerializeStruct;
5633 let mut len = 0;
5634 if self.key_required_larger != 0 {
5635 len += 1;
5636 }
5637 if self.key_required_smaller != 0 {
5638 len += 1;
5639 }
5640 if self.clean_state {
5641 len += 1;
5642 }
5643 if self.delta_expression.is_some() {
5644 len += 1;
5645 }
5646 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5647 if self.key_required_larger != 0 {
5648 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5649 }
5650 if self.key_required_smaller != 0 {
5651 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5652 }
5653 if self.clean_state {
5654 struct_ser.serialize_field("cleanState", &self.clean_state)?;
5655 }
5656 if let Some(v) = self.delta_expression.as_ref() {
5657 struct_ser.serialize_field("deltaExpression", v)?;
5658 }
5659 struct_ser.end()
5660 }
5661}
5662impl<'de> serde::Deserialize<'de> for InequalityPair {
5663 #[allow(deprecated)]
5664 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5665 where
5666 D: serde::Deserializer<'de>,
5667 {
5668 const FIELDS: &[&str] = &[
5669 "key_required_larger",
5670 "keyRequiredLarger",
5671 "key_required_smaller",
5672 "keyRequiredSmaller",
5673 "clean_state",
5674 "cleanState",
5675 "delta_expression",
5676 "deltaExpression",
5677 ];
5678
5679 #[allow(clippy::enum_variant_names)]
5680 enum GeneratedField {
5681 KeyRequiredLarger,
5682 KeyRequiredSmaller,
5683 CleanState,
5684 DeltaExpression,
5685 }
5686 impl<'de> serde::Deserialize<'de> for GeneratedField {
5687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5688 where
5689 D: serde::Deserializer<'de>,
5690 {
5691 struct GeneratedVisitor;
5692
5693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5694 type Value = GeneratedField;
5695
5696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5697 write!(formatter, "expected one of: {:?}", &FIELDS)
5698 }
5699
5700 #[allow(unused_variables)]
5701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5702 where
5703 E: serde::de::Error,
5704 {
5705 match value {
5706 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
5707 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
5708 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
5709 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
5710 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5711 }
5712 }
5713 }
5714 deserializer.deserialize_identifier(GeneratedVisitor)
5715 }
5716 }
5717 struct GeneratedVisitor;
5718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5719 type Value = InequalityPair;
5720
5721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5722 formatter.write_str("struct stream_plan.InequalityPair")
5723 }
5724
5725 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
5726 where
5727 V: serde::de::MapAccess<'de>,
5728 {
5729 let mut key_required_larger__ = None;
5730 let mut key_required_smaller__ = None;
5731 let mut clean_state__ = None;
5732 let mut delta_expression__ = None;
5733 while let Some(k) = map_.next_key()? {
5734 match k {
5735 GeneratedField::KeyRequiredLarger => {
5736 if key_required_larger__.is_some() {
5737 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
5738 }
5739 key_required_larger__ =
5740 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5741 ;
5742 }
5743 GeneratedField::KeyRequiredSmaller => {
5744 if key_required_smaller__.is_some() {
5745 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
5746 }
5747 key_required_smaller__ =
5748 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5749 ;
5750 }
5751 GeneratedField::CleanState => {
5752 if clean_state__.is_some() {
5753 return Err(serde::de::Error::duplicate_field("cleanState"));
5754 }
5755 clean_state__ = Some(map_.next_value()?);
5756 }
5757 GeneratedField::DeltaExpression => {
5758 if delta_expression__.is_some() {
5759 return Err(serde::de::Error::duplicate_field("deltaExpression"));
5760 }
5761 delta_expression__ = map_.next_value()?;
5762 }
5763 }
5764 }
5765 Ok(InequalityPair {
5766 key_required_larger: key_required_larger__.unwrap_or_default(),
5767 key_required_smaller: key_required_smaller__.unwrap_or_default(),
5768 clean_state: clean_state__.unwrap_or_default(),
5769 delta_expression: delta_expression__,
5770 })
5771 }
5772 }
5773 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
5774 }
5775}
5776impl serde::Serialize for LocalApproxPercentileNode {
5777 #[allow(deprecated)]
5778 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5779 where
5780 S: serde::Serializer,
5781 {
5782 use serde::ser::SerializeStruct;
5783 let mut len = 0;
5784 if self.base != 0. {
5785 len += 1;
5786 }
5787 if self.percentile_index != 0 {
5788 len += 1;
5789 }
5790 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
5791 if self.base != 0. {
5792 struct_ser.serialize_field("base", &self.base)?;
5793 }
5794 if self.percentile_index != 0 {
5795 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
5796 }
5797 struct_ser.end()
5798 }
5799}
5800impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
5801 #[allow(deprecated)]
5802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5803 where
5804 D: serde::Deserializer<'de>,
5805 {
5806 const FIELDS: &[&str] = &[
5807 "base",
5808 "percentile_index",
5809 "percentileIndex",
5810 ];
5811
5812 #[allow(clippy::enum_variant_names)]
5813 enum GeneratedField {
5814 Base,
5815 PercentileIndex,
5816 }
5817 impl<'de> serde::Deserialize<'de> for GeneratedField {
5818 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5819 where
5820 D: serde::Deserializer<'de>,
5821 {
5822 struct GeneratedVisitor;
5823
5824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5825 type Value = GeneratedField;
5826
5827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5828 write!(formatter, "expected one of: {:?}", &FIELDS)
5829 }
5830
5831 #[allow(unused_variables)]
5832 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5833 where
5834 E: serde::de::Error,
5835 {
5836 match value {
5837 "base" => Ok(GeneratedField::Base),
5838 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
5839 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5840 }
5841 }
5842 }
5843 deserializer.deserialize_identifier(GeneratedVisitor)
5844 }
5845 }
5846 struct GeneratedVisitor;
5847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5848 type Value = LocalApproxPercentileNode;
5849
5850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5851 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
5852 }
5853
5854 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
5855 where
5856 V: serde::de::MapAccess<'de>,
5857 {
5858 let mut base__ = None;
5859 let mut percentile_index__ = None;
5860 while let Some(k) = map_.next_key()? {
5861 match k {
5862 GeneratedField::Base => {
5863 if base__.is_some() {
5864 return Err(serde::de::Error::duplicate_field("base"));
5865 }
5866 base__ =
5867 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5868 ;
5869 }
5870 GeneratedField::PercentileIndex => {
5871 if percentile_index__.is_some() {
5872 return Err(serde::de::Error::duplicate_field("percentileIndex"));
5873 }
5874 percentile_index__ =
5875 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5876 ;
5877 }
5878 }
5879 }
5880 Ok(LocalApproxPercentileNode {
5881 base: base__.unwrap_or_default(),
5882 percentile_index: percentile_index__.unwrap_or_default(),
5883 })
5884 }
5885 }
5886 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
5887 }
5888}
5889impl serde::Serialize for LookupNode {
5890 #[allow(deprecated)]
5891 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5892 where
5893 S: serde::Serializer,
5894 {
5895 use serde::ser::SerializeStruct;
5896 let mut len = 0;
5897 if !self.arrange_key.is_empty() {
5898 len += 1;
5899 }
5900 if !self.stream_key.is_empty() {
5901 len += 1;
5902 }
5903 if self.use_current_epoch {
5904 len += 1;
5905 }
5906 if !self.column_mapping.is_empty() {
5907 len += 1;
5908 }
5909 if self.arrangement_table_info.is_some() {
5910 len += 1;
5911 }
5912 if self.arrangement_table_id.is_some() {
5913 len += 1;
5914 }
5915 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
5916 if !self.arrange_key.is_empty() {
5917 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
5918 }
5919 if !self.stream_key.is_empty() {
5920 struct_ser.serialize_field("streamKey", &self.stream_key)?;
5921 }
5922 if self.use_current_epoch {
5923 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
5924 }
5925 if !self.column_mapping.is_empty() {
5926 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
5927 }
5928 if let Some(v) = self.arrangement_table_info.as_ref() {
5929 struct_ser.serialize_field("arrangementTableInfo", v)?;
5930 }
5931 if let Some(v) = self.arrangement_table_id.as_ref() {
5932 match v {
5933 lookup_node::ArrangementTableId::TableId(v) => {
5934 struct_ser.serialize_field("tableId", v)?;
5935 }
5936 lookup_node::ArrangementTableId::IndexId(v) => {
5937 struct_ser.serialize_field("indexId", v)?;
5938 }
5939 }
5940 }
5941 struct_ser.end()
5942 }
5943}
5944impl<'de> serde::Deserialize<'de> for LookupNode {
5945 #[allow(deprecated)]
5946 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5947 where
5948 D: serde::Deserializer<'de>,
5949 {
5950 const FIELDS: &[&str] = &[
5951 "arrange_key",
5952 "arrangeKey",
5953 "stream_key",
5954 "streamKey",
5955 "use_current_epoch",
5956 "useCurrentEpoch",
5957 "column_mapping",
5958 "columnMapping",
5959 "arrangement_table_info",
5960 "arrangementTableInfo",
5961 "table_id",
5962 "tableId",
5963 "index_id",
5964 "indexId",
5965 ];
5966
5967 #[allow(clippy::enum_variant_names)]
5968 enum GeneratedField {
5969 ArrangeKey,
5970 StreamKey,
5971 UseCurrentEpoch,
5972 ColumnMapping,
5973 ArrangementTableInfo,
5974 TableId,
5975 IndexId,
5976 }
5977 impl<'de> serde::Deserialize<'de> for GeneratedField {
5978 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5979 where
5980 D: serde::Deserializer<'de>,
5981 {
5982 struct GeneratedVisitor;
5983
5984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5985 type Value = GeneratedField;
5986
5987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5988 write!(formatter, "expected one of: {:?}", &FIELDS)
5989 }
5990
5991 #[allow(unused_variables)]
5992 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5993 where
5994 E: serde::de::Error,
5995 {
5996 match value {
5997 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
5998 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
5999 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6000 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6001 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6002 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6003 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6005 }
6006 }
6007 }
6008 deserializer.deserialize_identifier(GeneratedVisitor)
6009 }
6010 }
6011 struct GeneratedVisitor;
6012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6013 type Value = LookupNode;
6014
6015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6016 formatter.write_str("struct stream_plan.LookupNode")
6017 }
6018
6019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6020 where
6021 V: serde::de::MapAccess<'de>,
6022 {
6023 let mut arrange_key__ = None;
6024 let mut stream_key__ = None;
6025 let mut use_current_epoch__ = None;
6026 let mut column_mapping__ = None;
6027 let mut arrangement_table_info__ = None;
6028 let mut arrangement_table_id__ = None;
6029 while let Some(k) = map_.next_key()? {
6030 match k {
6031 GeneratedField::ArrangeKey => {
6032 if arrange_key__.is_some() {
6033 return Err(serde::de::Error::duplicate_field("arrangeKey"));
6034 }
6035 arrange_key__ =
6036 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6037 .into_iter().map(|x| x.0).collect())
6038 ;
6039 }
6040 GeneratedField::StreamKey => {
6041 if stream_key__.is_some() {
6042 return Err(serde::de::Error::duplicate_field("streamKey"));
6043 }
6044 stream_key__ =
6045 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6046 .into_iter().map(|x| x.0).collect())
6047 ;
6048 }
6049 GeneratedField::UseCurrentEpoch => {
6050 if use_current_epoch__.is_some() {
6051 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6052 }
6053 use_current_epoch__ = Some(map_.next_value()?);
6054 }
6055 GeneratedField::ColumnMapping => {
6056 if column_mapping__.is_some() {
6057 return Err(serde::de::Error::duplicate_field("columnMapping"));
6058 }
6059 column_mapping__ =
6060 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6061 .into_iter().map(|x| x.0).collect())
6062 ;
6063 }
6064 GeneratedField::ArrangementTableInfo => {
6065 if arrangement_table_info__.is_some() {
6066 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6067 }
6068 arrangement_table_info__ = map_.next_value()?;
6069 }
6070 GeneratedField::TableId => {
6071 if arrangement_table_id__.is_some() {
6072 return Err(serde::de::Error::duplicate_field("tableId"));
6073 }
6074 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6075 }
6076 GeneratedField::IndexId => {
6077 if arrangement_table_id__.is_some() {
6078 return Err(serde::de::Error::duplicate_field("indexId"));
6079 }
6080 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6081 }
6082 }
6083 }
6084 Ok(LookupNode {
6085 arrange_key: arrange_key__.unwrap_or_default(),
6086 stream_key: stream_key__.unwrap_or_default(),
6087 use_current_epoch: use_current_epoch__.unwrap_or_default(),
6088 column_mapping: column_mapping__.unwrap_or_default(),
6089 arrangement_table_info: arrangement_table_info__,
6090 arrangement_table_id: arrangement_table_id__,
6091 })
6092 }
6093 }
6094 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6095 }
6096}
6097impl serde::Serialize for LookupUnionNode {
6098 #[allow(deprecated)]
6099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6100 where
6101 S: serde::Serializer,
6102 {
6103 use serde::ser::SerializeStruct;
6104 let mut len = 0;
6105 if !self.order.is_empty() {
6106 len += 1;
6107 }
6108 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6109 if !self.order.is_empty() {
6110 struct_ser.serialize_field("order", &self.order)?;
6111 }
6112 struct_ser.end()
6113 }
6114}
6115impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6116 #[allow(deprecated)]
6117 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6118 where
6119 D: serde::Deserializer<'de>,
6120 {
6121 const FIELDS: &[&str] = &[
6122 "order",
6123 ];
6124
6125 #[allow(clippy::enum_variant_names)]
6126 enum GeneratedField {
6127 Order,
6128 }
6129 impl<'de> serde::Deserialize<'de> for GeneratedField {
6130 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6131 where
6132 D: serde::Deserializer<'de>,
6133 {
6134 struct GeneratedVisitor;
6135
6136 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6137 type Value = GeneratedField;
6138
6139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6140 write!(formatter, "expected one of: {:?}", &FIELDS)
6141 }
6142
6143 #[allow(unused_variables)]
6144 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6145 where
6146 E: serde::de::Error,
6147 {
6148 match value {
6149 "order" => Ok(GeneratedField::Order),
6150 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6151 }
6152 }
6153 }
6154 deserializer.deserialize_identifier(GeneratedVisitor)
6155 }
6156 }
6157 struct GeneratedVisitor;
6158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6159 type Value = LookupUnionNode;
6160
6161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6162 formatter.write_str("struct stream_plan.LookupUnionNode")
6163 }
6164
6165 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6166 where
6167 V: serde::de::MapAccess<'de>,
6168 {
6169 let mut order__ = None;
6170 while let Some(k) = map_.next_key()? {
6171 match k {
6172 GeneratedField::Order => {
6173 if order__.is_some() {
6174 return Err(serde::de::Error::duplicate_field("order"));
6175 }
6176 order__ =
6177 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6178 .into_iter().map(|x| x.0).collect())
6179 ;
6180 }
6181 }
6182 }
6183 Ok(LookupUnionNode {
6184 order: order__.unwrap_or_default(),
6185 })
6186 }
6187 }
6188 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6189 }
6190}
6191impl serde::Serialize for MaterializeNode {
6192 #[allow(deprecated)]
6193 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6194 where
6195 S: serde::Serializer,
6196 {
6197 use serde::ser::SerializeStruct;
6198 let mut len = 0;
6199 if self.table_id != 0 {
6200 len += 1;
6201 }
6202 if !self.column_orders.is_empty() {
6203 len += 1;
6204 }
6205 if self.table.is_some() {
6206 len += 1;
6207 }
6208 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6209 if self.table_id != 0 {
6210 struct_ser.serialize_field("tableId", &self.table_id)?;
6211 }
6212 if !self.column_orders.is_empty() {
6213 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6214 }
6215 if let Some(v) = self.table.as_ref() {
6216 struct_ser.serialize_field("table", v)?;
6217 }
6218 struct_ser.end()
6219 }
6220}
6221impl<'de> serde::Deserialize<'de> for MaterializeNode {
6222 #[allow(deprecated)]
6223 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6224 where
6225 D: serde::Deserializer<'de>,
6226 {
6227 const FIELDS: &[&str] = &[
6228 "table_id",
6229 "tableId",
6230 "column_orders",
6231 "columnOrders",
6232 "table",
6233 ];
6234
6235 #[allow(clippy::enum_variant_names)]
6236 enum GeneratedField {
6237 TableId,
6238 ColumnOrders,
6239 Table,
6240 }
6241 impl<'de> serde::Deserialize<'de> for GeneratedField {
6242 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6243 where
6244 D: serde::Deserializer<'de>,
6245 {
6246 struct GeneratedVisitor;
6247
6248 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6249 type Value = GeneratedField;
6250
6251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6252 write!(formatter, "expected one of: {:?}", &FIELDS)
6253 }
6254
6255 #[allow(unused_variables)]
6256 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6257 where
6258 E: serde::de::Error,
6259 {
6260 match value {
6261 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6262 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6263 "table" => Ok(GeneratedField::Table),
6264 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6265 }
6266 }
6267 }
6268 deserializer.deserialize_identifier(GeneratedVisitor)
6269 }
6270 }
6271 struct GeneratedVisitor;
6272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6273 type Value = MaterializeNode;
6274
6275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6276 formatter.write_str("struct stream_plan.MaterializeNode")
6277 }
6278
6279 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6280 where
6281 V: serde::de::MapAccess<'de>,
6282 {
6283 let mut table_id__ = None;
6284 let mut column_orders__ = None;
6285 let mut table__ = None;
6286 while let Some(k) = map_.next_key()? {
6287 match k {
6288 GeneratedField::TableId => {
6289 if table_id__.is_some() {
6290 return Err(serde::de::Error::duplicate_field("tableId"));
6291 }
6292 table_id__ =
6293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6294 ;
6295 }
6296 GeneratedField::ColumnOrders => {
6297 if column_orders__.is_some() {
6298 return Err(serde::de::Error::duplicate_field("columnOrders"));
6299 }
6300 column_orders__ = Some(map_.next_value()?);
6301 }
6302 GeneratedField::Table => {
6303 if table__.is_some() {
6304 return Err(serde::de::Error::duplicate_field("table"));
6305 }
6306 table__ = map_.next_value()?;
6307 }
6308 }
6309 }
6310 Ok(MaterializeNode {
6311 table_id: table_id__.unwrap_or_default(),
6312 column_orders: column_orders__.unwrap_or_default(),
6313 table: table__,
6314 })
6315 }
6316 }
6317 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6318 }
6319}
6320impl serde::Serialize for MaterializedExprsNode {
6321 #[allow(deprecated)]
6322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6323 where
6324 S: serde::Serializer,
6325 {
6326 use serde::ser::SerializeStruct;
6327 let mut len = 0;
6328 if !self.exprs.is_empty() {
6329 len += 1;
6330 }
6331 if self.state_table.is_some() {
6332 len += 1;
6333 }
6334 if self.state_clean_col_idx.is_some() {
6335 len += 1;
6336 }
6337 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6338 if !self.exprs.is_empty() {
6339 struct_ser.serialize_field("exprs", &self.exprs)?;
6340 }
6341 if let Some(v) = self.state_table.as_ref() {
6342 struct_ser.serialize_field("stateTable", v)?;
6343 }
6344 if let Some(v) = self.state_clean_col_idx.as_ref() {
6345 struct_ser.serialize_field("stateCleanColIdx", v)?;
6346 }
6347 struct_ser.end()
6348 }
6349}
6350impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6351 #[allow(deprecated)]
6352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6353 where
6354 D: serde::Deserializer<'de>,
6355 {
6356 const FIELDS: &[&str] = &[
6357 "exprs",
6358 "state_table",
6359 "stateTable",
6360 "state_clean_col_idx",
6361 "stateCleanColIdx",
6362 ];
6363
6364 #[allow(clippy::enum_variant_names)]
6365 enum GeneratedField {
6366 Exprs,
6367 StateTable,
6368 StateCleanColIdx,
6369 }
6370 impl<'de> serde::Deserialize<'de> for GeneratedField {
6371 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6372 where
6373 D: serde::Deserializer<'de>,
6374 {
6375 struct GeneratedVisitor;
6376
6377 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6378 type Value = GeneratedField;
6379
6380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6381 write!(formatter, "expected one of: {:?}", &FIELDS)
6382 }
6383
6384 #[allow(unused_variables)]
6385 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6386 where
6387 E: serde::de::Error,
6388 {
6389 match value {
6390 "exprs" => Ok(GeneratedField::Exprs),
6391 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6392 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
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 = MaterializedExprsNode;
6403
6404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6405 formatter.write_str("struct stream_plan.MaterializedExprsNode")
6406 }
6407
6408 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6409 where
6410 V: serde::de::MapAccess<'de>,
6411 {
6412 let mut exprs__ = None;
6413 let mut state_table__ = None;
6414 let mut state_clean_col_idx__ = None;
6415 while let Some(k) = map_.next_key()? {
6416 match k {
6417 GeneratedField::Exprs => {
6418 if exprs__.is_some() {
6419 return Err(serde::de::Error::duplicate_field("exprs"));
6420 }
6421 exprs__ = Some(map_.next_value()?);
6422 }
6423 GeneratedField::StateTable => {
6424 if state_table__.is_some() {
6425 return Err(serde::de::Error::duplicate_field("stateTable"));
6426 }
6427 state_table__ = map_.next_value()?;
6428 }
6429 GeneratedField::StateCleanColIdx => {
6430 if state_clean_col_idx__.is_some() {
6431 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6432 }
6433 state_clean_col_idx__ =
6434 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6435 ;
6436 }
6437 }
6438 }
6439 Ok(MaterializedExprsNode {
6440 exprs: exprs__.unwrap_or_default(),
6441 state_table: state_table__,
6442 state_clean_col_idx: state_clean_col_idx__,
6443 })
6444 }
6445 }
6446 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6447 }
6448}
6449impl serde::Serialize for MergeNode {
6450 #[allow(deprecated)]
6451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6452 where
6453 S: serde::Serializer,
6454 {
6455 use serde::ser::SerializeStruct;
6456 let mut len = 0;
6457 if !self.upstream_actor_id.is_empty() {
6458 len += 1;
6459 }
6460 if self.upstream_fragment_id != 0 {
6461 len += 1;
6462 }
6463 if self.upstream_dispatcher_type != 0 {
6464 len += 1;
6465 }
6466 if !self.fields.is_empty() {
6467 len += 1;
6468 }
6469 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
6470 if !self.upstream_actor_id.is_empty() {
6471 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
6472 }
6473 if self.upstream_fragment_id != 0 {
6474 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
6475 }
6476 if self.upstream_dispatcher_type != 0 {
6477 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
6478 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
6479 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
6480 }
6481 if !self.fields.is_empty() {
6482 struct_ser.serialize_field("fields", &self.fields)?;
6483 }
6484 struct_ser.end()
6485 }
6486}
6487impl<'de> serde::Deserialize<'de> for MergeNode {
6488 #[allow(deprecated)]
6489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6490 where
6491 D: serde::Deserializer<'de>,
6492 {
6493 const FIELDS: &[&str] = &[
6494 "upstream_actor_id",
6495 "upstreamActorId",
6496 "upstream_fragment_id",
6497 "upstreamFragmentId",
6498 "upstream_dispatcher_type",
6499 "upstreamDispatcherType",
6500 "fields",
6501 ];
6502
6503 #[allow(clippy::enum_variant_names)]
6504 enum GeneratedField {
6505 UpstreamActorId,
6506 UpstreamFragmentId,
6507 UpstreamDispatcherType,
6508 Fields,
6509 }
6510 impl<'de> serde::Deserialize<'de> for GeneratedField {
6511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6512 where
6513 D: serde::Deserializer<'de>,
6514 {
6515 struct GeneratedVisitor;
6516
6517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6518 type Value = GeneratedField;
6519
6520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6521 write!(formatter, "expected one of: {:?}", &FIELDS)
6522 }
6523
6524 #[allow(unused_variables)]
6525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6526 where
6527 E: serde::de::Error,
6528 {
6529 match value {
6530 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
6531 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
6532 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
6533 "fields" => Ok(GeneratedField::Fields),
6534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6535 }
6536 }
6537 }
6538 deserializer.deserialize_identifier(GeneratedVisitor)
6539 }
6540 }
6541 struct GeneratedVisitor;
6542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6543 type Value = MergeNode;
6544
6545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6546 formatter.write_str("struct stream_plan.MergeNode")
6547 }
6548
6549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
6550 where
6551 V: serde::de::MapAccess<'de>,
6552 {
6553 let mut upstream_actor_id__ = None;
6554 let mut upstream_fragment_id__ = None;
6555 let mut upstream_dispatcher_type__ = None;
6556 let mut fields__ = None;
6557 while let Some(k) = map_.next_key()? {
6558 match k {
6559 GeneratedField::UpstreamActorId => {
6560 if upstream_actor_id__.is_some() {
6561 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
6562 }
6563 upstream_actor_id__ =
6564 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6565 .into_iter().map(|x| x.0).collect())
6566 ;
6567 }
6568 GeneratedField::UpstreamFragmentId => {
6569 if upstream_fragment_id__.is_some() {
6570 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
6571 }
6572 upstream_fragment_id__ =
6573 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6574 ;
6575 }
6576 GeneratedField::UpstreamDispatcherType => {
6577 if upstream_dispatcher_type__.is_some() {
6578 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
6579 }
6580 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
6581 }
6582 GeneratedField::Fields => {
6583 if fields__.is_some() {
6584 return Err(serde::de::Error::duplicate_field("fields"));
6585 }
6586 fields__ = Some(map_.next_value()?);
6587 }
6588 }
6589 }
6590 Ok(MergeNode {
6591 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
6592 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
6593 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
6594 fields: fields__.unwrap_or_default(),
6595 })
6596 }
6597 }
6598 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
6599 }
6600}
6601impl serde::Serialize for NoOpNode {
6602 #[allow(deprecated)]
6603 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6604 where
6605 S: serde::Serializer,
6606 {
6607 use serde::ser::SerializeStruct;
6608 let len = 0;
6609 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
6610 struct_ser.end()
6611 }
6612}
6613impl<'de> serde::Deserialize<'de> for NoOpNode {
6614 #[allow(deprecated)]
6615 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6616 where
6617 D: serde::Deserializer<'de>,
6618 {
6619 const FIELDS: &[&str] = &[
6620 ];
6621
6622 #[allow(clippy::enum_variant_names)]
6623 enum GeneratedField {
6624 }
6625 impl<'de> serde::Deserialize<'de> for GeneratedField {
6626 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6627 where
6628 D: serde::Deserializer<'de>,
6629 {
6630 struct GeneratedVisitor;
6631
6632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6633 type Value = GeneratedField;
6634
6635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6636 write!(formatter, "expected one of: {:?}", &FIELDS)
6637 }
6638
6639 #[allow(unused_variables)]
6640 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6641 where
6642 E: serde::de::Error,
6643 {
6644 Err(serde::de::Error::unknown_field(value, FIELDS))
6645 }
6646 }
6647 deserializer.deserialize_identifier(GeneratedVisitor)
6648 }
6649 }
6650 struct GeneratedVisitor;
6651 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6652 type Value = NoOpNode;
6653
6654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6655 formatter.write_str("struct stream_plan.NoOpNode")
6656 }
6657
6658 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
6659 where
6660 V: serde::de::MapAccess<'de>,
6661 {
6662 while map_.next_key::<GeneratedField>()?.is_some() {
6663 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6664 }
6665 Ok(NoOpNode {
6666 })
6667 }
6668 }
6669 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
6670 }
6671}
6672impl serde::Serialize for NowModeGenerateSeries {
6673 #[allow(deprecated)]
6674 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6675 where
6676 S: serde::Serializer,
6677 {
6678 use serde::ser::SerializeStruct;
6679 let mut len = 0;
6680 if self.start_timestamp.is_some() {
6681 len += 1;
6682 }
6683 if self.interval.is_some() {
6684 len += 1;
6685 }
6686 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
6687 if let Some(v) = self.start_timestamp.as_ref() {
6688 struct_ser.serialize_field("startTimestamp", v)?;
6689 }
6690 if let Some(v) = self.interval.as_ref() {
6691 struct_ser.serialize_field("interval", v)?;
6692 }
6693 struct_ser.end()
6694 }
6695}
6696impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
6697 #[allow(deprecated)]
6698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6699 where
6700 D: serde::Deserializer<'de>,
6701 {
6702 const FIELDS: &[&str] = &[
6703 "start_timestamp",
6704 "startTimestamp",
6705 "interval",
6706 ];
6707
6708 #[allow(clippy::enum_variant_names)]
6709 enum GeneratedField {
6710 StartTimestamp,
6711 Interval,
6712 }
6713 impl<'de> serde::Deserialize<'de> for GeneratedField {
6714 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6715 where
6716 D: serde::Deserializer<'de>,
6717 {
6718 struct GeneratedVisitor;
6719
6720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6721 type Value = GeneratedField;
6722
6723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6724 write!(formatter, "expected one of: {:?}", &FIELDS)
6725 }
6726
6727 #[allow(unused_variables)]
6728 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6729 where
6730 E: serde::de::Error,
6731 {
6732 match value {
6733 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
6734 "interval" => Ok(GeneratedField::Interval),
6735 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6736 }
6737 }
6738 }
6739 deserializer.deserialize_identifier(GeneratedVisitor)
6740 }
6741 }
6742 struct GeneratedVisitor;
6743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6744 type Value = NowModeGenerateSeries;
6745
6746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6747 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
6748 }
6749
6750 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
6751 where
6752 V: serde::de::MapAccess<'de>,
6753 {
6754 let mut start_timestamp__ = None;
6755 let mut interval__ = None;
6756 while let Some(k) = map_.next_key()? {
6757 match k {
6758 GeneratedField::StartTimestamp => {
6759 if start_timestamp__.is_some() {
6760 return Err(serde::de::Error::duplicate_field("startTimestamp"));
6761 }
6762 start_timestamp__ = map_.next_value()?;
6763 }
6764 GeneratedField::Interval => {
6765 if interval__.is_some() {
6766 return Err(serde::de::Error::duplicate_field("interval"));
6767 }
6768 interval__ = map_.next_value()?;
6769 }
6770 }
6771 }
6772 Ok(NowModeGenerateSeries {
6773 start_timestamp: start_timestamp__,
6774 interval: interval__,
6775 })
6776 }
6777 }
6778 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
6779 }
6780}
6781impl serde::Serialize for NowModeUpdateCurrent {
6782 #[allow(deprecated)]
6783 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6784 where
6785 S: serde::Serializer,
6786 {
6787 use serde::ser::SerializeStruct;
6788 let len = 0;
6789 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
6790 struct_ser.end()
6791 }
6792}
6793impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
6794 #[allow(deprecated)]
6795 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6796 where
6797 D: serde::Deserializer<'de>,
6798 {
6799 const FIELDS: &[&str] = &[
6800 ];
6801
6802 #[allow(clippy::enum_variant_names)]
6803 enum GeneratedField {
6804 }
6805 impl<'de> serde::Deserialize<'de> for GeneratedField {
6806 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6807 where
6808 D: serde::Deserializer<'de>,
6809 {
6810 struct GeneratedVisitor;
6811
6812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6813 type Value = GeneratedField;
6814
6815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6816 write!(formatter, "expected one of: {:?}", &FIELDS)
6817 }
6818
6819 #[allow(unused_variables)]
6820 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6821 where
6822 E: serde::de::Error,
6823 {
6824 Err(serde::de::Error::unknown_field(value, FIELDS))
6825 }
6826 }
6827 deserializer.deserialize_identifier(GeneratedVisitor)
6828 }
6829 }
6830 struct GeneratedVisitor;
6831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6832 type Value = NowModeUpdateCurrent;
6833
6834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6835 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
6836 }
6837
6838 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
6839 where
6840 V: serde::de::MapAccess<'de>,
6841 {
6842 while map_.next_key::<GeneratedField>()?.is_some() {
6843 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6844 }
6845 Ok(NowModeUpdateCurrent {
6846 })
6847 }
6848 }
6849 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
6850 }
6851}
6852impl serde::Serialize for NowNode {
6853 #[allow(deprecated)]
6854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6855 where
6856 S: serde::Serializer,
6857 {
6858 use serde::ser::SerializeStruct;
6859 let mut len = 0;
6860 if self.state_table.is_some() {
6861 len += 1;
6862 }
6863 if self.mode.is_some() {
6864 len += 1;
6865 }
6866 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
6867 if let Some(v) = self.state_table.as_ref() {
6868 struct_ser.serialize_field("stateTable", v)?;
6869 }
6870 if let Some(v) = self.mode.as_ref() {
6871 match v {
6872 now_node::Mode::UpdateCurrent(v) => {
6873 struct_ser.serialize_field("updateCurrent", v)?;
6874 }
6875 now_node::Mode::GenerateSeries(v) => {
6876 struct_ser.serialize_field("generateSeries", v)?;
6877 }
6878 }
6879 }
6880 struct_ser.end()
6881 }
6882}
6883impl<'de> serde::Deserialize<'de> for NowNode {
6884 #[allow(deprecated)]
6885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6886 where
6887 D: serde::Deserializer<'de>,
6888 {
6889 const FIELDS: &[&str] = &[
6890 "state_table",
6891 "stateTable",
6892 "update_current",
6893 "updateCurrent",
6894 "generate_series",
6895 "generateSeries",
6896 ];
6897
6898 #[allow(clippy::enum_variant_names)]
6899 enum GeneratedField {
6900 StateTable,
6901 UpdateCurrent,
6902 GenerateSeries,
6903 }
6904 impl<'de> serde::Deserialize<'de> for GeneratedField {
6905 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6906 where
6907 D: serde::Deserializer<'de>,
6908 {
6909 struct GeneratedVisitor;
6910
6911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6912 type Value = GeneratedField;
6913
6914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6915 write!(formatter, "expected one of: {:?}", &FIELDS)
6916 }
6917
6918 #[allow(unused_variables)]
6919 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6920 where
6921 E: serde::de::Error,
6922 {
6923 match value {
6924 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6925 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
6926 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
6927 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6928 }
6929 }
6930 }
6931 deserializer.deserialize_identifier(GeneratedVisitor)
6932 }
6933 }
6934 struct GeneratedVisitor;
6935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6936 type Value = NowNode;
6937
6938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6939 formatter.write_str("struct stream_plan.NowNode")
6940 }
6941
6942 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
6943 where
6944 V: serde::de::MapAccess<'de>,
6945 {
6946 let mut state_table__ = None;
6947 let mut mode__ = None;
6948 while let Some(k) = map_.next_key()? {
6949 match k {
6950 GeneratedField::StateTable => {
6951 if state_table__.is_some() {
6952 return Err(serde::de::Error::duplicate_field("stateTable"));
6953 }
6954 state_table__ = map_.next_value()?;
6955 }
6956 GeneratedField::UpdateCurrent => {
6957 if mode__.is_some() {
6958 return Err(serde::de::Error::duplicate_field("updateCurrent"));
6959 }
6960 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
6961;
6962 }
6963 GeneratedField::GenerateSeries => {
6964 if mode__.is_some() {
6965 return Err(serde::de::Error::duplicate_field("generateSeries"));
6966 }
6967 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
6968;
6969 }
6970 }
6971 }
6972 Ok(NowNode {
6973 state_table: state_table__,
6974 mode: mode__,
6975 })
6976 }
6977 }
6978 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
6979 }
6980}
6981impl serde::Serialize for OverWindowCachePolicy {
6982 #[allow(deprecated)]
6983 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6984 where
6985 S: serde::Serializer,
6986 {
6987 let variant = match self {
6988 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
6989 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
6990 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
6991 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
6992 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
6993 };
6994 serializer.serialize_str(variant)
6995 }
6996}
6997impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
6998 #[allow(deprecated)]
6999 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7000 where
7001 D: serde::Deserializer<'de>,
7002 {
7003 const FIELDS: &[&str] = &[
7004 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7005 "OVER_WINDOW_CACHE_POLICY_FULL",
7006 "OVER_WINDOW_CACHE_POLICY_RECENT",
7007 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7008 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7009 ];
7010
7011 struct GeneratedVisitor;
7012
7013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7014 type Value = OverWindowCachePolicy;
7015
7016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7017 write!(formatter, "expected one of: {:?}", &FIELDS)
7018 }
7019
7020 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7021 where
7022 E: serde::de::Error,
7023 {
7024 i32::try_from(v)
7025 .ok()
7026 .and_then(|x| x.try_into().ok())
7027 .ok_or_else(|| {
7028 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7029 })
7030 }
7031
7032 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7033 where
7034 E: serde::de::Error,
7035 {
7036 i32::try_from(v)
7037 .ok()
7038 .and_then(|x| x.try_into().ok())
7039 .ok_or_else(|| {
7040 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7041 })
7042 }
7043
7044 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7045 where
7046 E: serde::de::Error,
7047 {
7048 match value {
7049 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7050 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7051 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7052 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7053 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7054 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7055 }
7056 }
7057 }
7058 deserializer.deserialize_any(GeneratedVisitor)
7059 }
7060}
7061impl serde::Serialize for OverWindowNode {
7062 #[allow(deprecated)]
7063 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7064 where
7065 S: serde::Serializer,
7066 {
7067 use serde::ser::SerializeStruct;
7068 let mut len = 0;
7069 if !self.calls.is_empty() {
7070 len += 1;
7071 }
7072 if !self.partition_by.is_empty() {
7073 len += 1;
7074 }
7075 if !self.order_by.is_empty() {
7076 len += 1;
7077 }
7078 if self.state_table.is_some() {
7079 len += 1;
7080 }
7081 if self.cache_policy != 0 {
7082 len += 1;
7083 }
7084 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7085 if !self.calls.is_empty() {
7086 struct_ser.serialize_field("calls", &self.calls)?;
7087 }
7088 if !self.partition_by.is_empty() {
7089 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7090 }
7091 if !self.order_by.is_empty() {
7092 struct_ser.serialize_field("orderBy", &self.order_by)?;
7093 }
7094 if let Some(v) = self.state_table.as_ref() {
7095 struct_ser.serialize_field("stateTable", v)?;
7096 }
7097 if self.cache_policy != 0 {
7098 let v = OverWindowCachePolicy::try_from(self.cache_policy)
7099 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7100 struct_ser.serialize_field("cachePolicy", &v)?;
7101 }
7102 struct_ser.end()
7103 }
7104}
7105impl<'de> serde::Deserialize<'de> for OverWindowNode {
7106 #[allow(deprecated)]
7107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7108 where
7109 D: serde::Deserializer<'de>,
7110 {
7111 const FIELDS: &[&str] = &[
7112 "calls",
7113 "partition_by",
7114 "partitionBy",
7115 "order_by",
7116 "orderBy",
7117 "state_table",
7118 "stateTable",
7119 "cache_policy",
7120 "cachePolicy",
7121 ];
7122
7123 #[allow(clippy::enum_variant_names)]
7124 enum GeneratedField {
7125 Calls,
7126 PartitionBy,
7127 OrderBy,
7128 StateTable,
7129 CachePolicy,
7130 }
7131 impl<'de> serde::Deserialize<'de> for GeneratedField {
7132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7133 where
7134 D: serde::Deserializer<'de>,
7135 {
7136 struct GeneratedVisitor;
7137
7138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7139 type Value = GeneratedField;
7140
7141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7142 write!(formatter, "expected one of: {:?}", &FIELDS)
7143 }
7144
7145 #[allow(unused_variables)]
7146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7147 where
7148 E: serde::de::Error,
7149 {
7150 match value {
7151 "calls" => Ok(GeneratedField::Calls),
7152 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7153 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7154 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7155 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7156 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7157 }
7158 }
7159 }
7160 deserializer.deserialize_identifier(GeneratedVisitor)
7161 }
7162 }
7163 struct GeneratedVisitor;
7164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7165 type Value = OverWindowNode;
7166
7167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7168 formatter.write_str("struct stream_plan.OverWindowNode")
7169 }
7170
7171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7172 where
7173 V: serde::de::MapAccess<'de>,
7174 {
7175 let mut calls__ = None;
7176 let mut partition_by__ = None;
7177 let mut order_by__ = None;
7178 let mut state_table__ = None;
7179 let mut cache_policy__ = None;
7180 while let Some(k) = map_.next_key()? {
7181 match k {
7182 GeneratedField::Calls => {
7183 if calls__.is_some() {
7184 return Err(serde::de::Error::duplicate_field("calls"));
7185 }
7186 calls__ = Some(map_.next_value()?);
7187 }
7188 GeneratedField::PartitionBy => {
7189 if partition_by__.is_some() {
7190 return Err(serde::de::Error::duplicate_field("partitionBy"));
7191 }
7192 partition_by__ =
7193 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7194 .into_iter().map(|x| x.0).collect())
7195 ;
7196 }
7197 GeneratedField::OrderBy => {
7198 if order_by__.is_some() {
7199 return Err(serde::de::Error::duplicate_field("orderBy"));
7200 }
7201 order_by__ = Some(map_.next_value()?);
7202 }
7203 GeneratedField::StateTable => {
7204 if state_table__.is_some() {
7205 return Err(serde::de::Error::duplicate_field("stateTable"));
7206 }
7207 state_table__ = map_.next_value()?;
7208 }
7209 GeneratedField::CachePolicy => {
7210 if cache_policy__.is_some() {
7211 return Err(serde::de::Error::duplicate_field("cachePolicy"));
7212 }
7213 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7214 }
7215 }
7216 }
7217 Ok(OverWindowNode {
7218 calls: calls__.unwrap_or_default(),
7219 partition_by: partition_by__.unwrap_or_default(),
7220 order_by: order_by__.unwrap_or_default(),
7221 state_table: state_table__,
7222 cache_policy: cache_policy__.unwrap_or_default(),
7223 })
7224 }
7225 }
7226 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7227 }
7228}
7229impl serde::Serialize for PauseMutation {
7230 #[allow(deprecated)]
7231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7232 where
7233 S: serde::Serializer,
7234 {
7235 use serde::ser::SerializeStruct;
7236 let len = 0;
7237 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7238 struct_ser.end()
7239 }
7240}
7241impl<'de> serde::Deserialize<'de> for PauseMutation {
7242 #[allow(deprecated)]
7243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7244 where
7245 D: serde::Deserializer<'de>,
7246 {
7247 const FIELDS: &[&str] = &[
7248 ];
7249
7250 #[allow(clippy::enum_variant_names)]
7251 enum GeneratedField {
7252 }
7253 impl<'de> serde::Deserialize<'de> for GeneratedField {
7254 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7255 where
7256 D: serde::Deserializer<'de>,
7257 {
7258 struct GeneratedVisitor;
7259
7260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7261 type Value = GeneratedField;
7262
7263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7264 write!(formatter, "expected one of: {:?}", &FIELDS)
7265 }
7266
7267 #[allow(unused_variables)]
7268 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7269 where
7270 E: serde::de::Error,
7271 {
7272 Err(serde::de::Error::unknown_field(value, FIELDS))
7273 }
7274 }
7275 deserializer.deserialize_identifier(GeneratedVisitor)
7276 }
7277 }
7278 struct GeneratedVisitor;
7279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7280 type Value = PauseMutation;
7281
7282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7283 formatter.write_str("struct stream_plan.PauseMutation")
7284 }
7285
7286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7287 where
7288 V: serde::de::MapAccess<'de>,
7289 {
7290 while map_.next_key::<GeneratedField>()?.is_some() {
7291 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7292 }
7293 Ok(PauseMutation {
7294 })
7295 }
7296 }
7297 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7298 }
7299}
7300impl serde::Serialize for ProjectNode {
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.select_list.is_empty() {
7309 len += 1;
7310 }
7311 if !self.watermark_input_cols.is_empty() {
7312 len += 1;
7313 }
7314 if !self.watermark_output_cols.is_empty() {
7315 len += 1;
7316 }
7317 if !self.nondecreasing_exprs.is_empty() {
7318 len += 1;
7319 }
7320 if self.noop_update_hint {
7321 len += 1;
7322 }
7323 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7324 if !self.select_list.is_empty() {
7325 struct_ser.serialize_field("selectList", &self.select_list)?;
7326 }
7327 if !self.watermark_input_cols.is_empty() {
7328 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7329 }
7330 if !self.watermark_output_cols.is_empty() {
7331 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7332 }
7333 if !self.nondecreasing_exprs.is_empty() {
7334 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7335 }
7336 if self.noop_update_hint {
7337 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7338 }
7339 struct_ser.end()
7340 }
7341}
7342impl<'de> serde::Deserialize<'de> for ProjectNode {
7343 #[allow(deprecated)]
7344 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7345 where
7346 D: serde::Deserializer<'de>,
7347 {
7348 const FIELDS: &[&str] = &[
7349 "select_list",
7350 "selectList",
7351 "watermark_input_cols",
7352 "watermarkInputCols",
7353 "watermark_output_cols",
7354 "watermarkOutputCols",
7355 "nondecreasing_exprs",
7356 "nondecreasingExprs",
7357 "noop_update_hint",
7358 "noopUpdateHint",
7359 ];
7360
7361 #[allow(clippy::enum_variant_names)]
7362 enum GeneratedField {
7363 SelectList,
7364 WatermarkInputCols,
7365 WatermarkOutputCols,
7366 NondecreasingExprs,
7367 NoopUpdateHint,
7368 }
7369 impl<'de> serde::Deserialize<'de> for GeneratedField {
7370 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7371 where
7372 D: serde::Deserializer<'de>,
7373 {
7374 struct GeneratedVisitor;
7375
7376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7377 type Value = GeneratedField;
7378
7379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7380 write!(formatter, "expected one of: {:?}", &FIELDS)
7381 }
7382
7383 #[allow(unused_variables)]
7384 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7385 where
7386 E: serde::de::Error,
7387 {
7388 match value {
7389 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7390 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7391 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7392 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7393 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7394 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7395 }
7396 }
7397 }
7398 deserializer.deserialize_identifier(GeneratedVisitor)
7399 }
7400 }
7401 struct GeneratedVisitor;
7402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7403 type Value = ProjectNode;
7404
7405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7406 formatter.write_str("struct stream_plan.ProjectNode")
7407 }
7408
7409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7410 where
7411 V: serde::de::MapAccess<'de>,
7412 {
7413 let mut select_list__ = None;
7414 let mut watermark_input_cols__ = None;
7415 let mut watermark_output_cols__ = None;
7416 let mut nondecreasing_exprs__ = None;
7417 let mut noop_update_hint__ = None;
7418 while let Some(k) = map_.next_key()? {
7419 match k {
7420 GeneratedField::SelectList => {
7421 if select_list__.is_some() {
7422 return Err(serde::de::Error::duplicate_field("selectList"));
7423 }
7424 select_list__ = Some(map_.next_value()?);
7425 }
7426 GeneratedField::WatermarkInputCols => {
7427 if watermark_input_cols__.is_some() {
7428 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7429 }
7430 watermark_input_cols__ =
7431 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7432 .into_iter().map(|x| x.0).collect())
7433 ;
7434 }
7435 GeneratedField::WatermarkOutputCols => {
7436 if watermark_output_cols__.is_some() {
7437 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7438 }
7439 watermark_output_cols__ =
7440 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7441 .into_iter().map(|x| x.0).collect())
7442 ;
7443 }
7444 GeneratedField::NondecreasingExprs => {
7445 if nondecreasing_exprs__.is_some() {
7446 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7447 }
7448 nondecreasing_exprs__ =
7449 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7450 .into_iter().map(|x| x.0).collect())
7451 ;
7452 }
7453 GeneratedField::NoopUpdateHint => {
7454 if noop_update_hint__.is_some() {
7455 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
7456 }
7457 noop_update_hint__ = Some(map_.next_value()?);
7458 }
7459 }
7460 }
7461 Ok(ProjectNode {
7462 select_list: select_list__.unwrap_or_default(),
7463 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7464 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
7465 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7466 noop_update_hint: noop_update_hint__.unwrap_or_default(),
7467 })
7468 }
7469 }
7470 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
7471 }
7472}
7473impl serde::Serialize for ProjectSetNode {
7474 #[allow(deprecated)]
7475 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7476 where
7477 S: serde::Serializer,
7478 {
7479 use serde::ser::SerializeStruct;
7480 let mut len = 0;
7481 if !self.select_list.is_empty() {
7482 len += 1;
7483 }
7484 if !self.watermark_input_cols.is_empty() {
7485 len += 1;
7486 }
7487 if !self.watermark_expr_indices.is_empty() {
7488 len += 1;
7489 }
7490 if !self.nondecreasing_exprs.is_empty() {
7491 len += 1;
7492 }
7493 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
7494 if !self.select_list.is_empty() {
7495 struct_ser.serialize_field("selectList", &self.select_list)?;
7496 }
7497 if !self.watermark_input_cols.is_empty() {
7498 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7499 }
7500 if !self.watermark_expr_indices.is_empty() {
7501 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
7502 }
7503 if !self.nondecreasing_exprs.is_empty() {
7504 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7505 }
7506 struct_ser.end()
7507 }
7508}
7509impl<'de> serde::Deserialize<'de> for ProjectSetNode {
7510 #[allow(deprecated)]
7511 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7512 where
7513 D: serde::Deserializer<'de>,
7514 {
7515 const FIELDS: &[&str] = &[
7516 "select_list",
7517 "selectList",
7518 "watermark_input_cols",
7519 "watermarkInputCols",
7520 "watermark_expr_indices",
7521 "watermarkExprIndices",
7522 "nondecreasing_exprs",
7523 "nondecreasingExprs",
7524 ];
7525
7526 #[allow(clippy::enum_variant_names)]
7527 enum GeneratedField {
7528 SelectList,
7529 WatermarkInputCols,
7530 WatermarkExprIndices,
7531 NondecreasingExprs,
7532 }
7533 impl<'de> serde::Deserialize<'de> for GeneratedField {
7534 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7535 where
7536 D: serde::Deserializer<'de>,
7537 {
7538 struct GeneratedVisitor;
7539
7540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7541 type Value = GeneratedField;
7542
7543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7544 write!(formatter, "expected one of: {:?}", &FIELDS)
7545 }
7546
7547 #[allow(unused_variables)]
7548 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7549 where
7550 E: serde::de::Error,
7551 {
7552 match value {
7553 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7554 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7555 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
7556 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7557 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7558 }
7559 }
7560 }
7561 deserializer.deserialize_identifier(GeneratedVisitor)
7562 }
7563 }
7564 struct GeneratedVisitor;
7565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7566 type Value = ProjectSetNode;
7567
7568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7569 formatter.write_str("struct stream_plan.ProjectSetNode")
7570 }
7571
7572 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
7573 where
7574 V: serde::de::MapAccess<'de>,
7575 {
7576 let mut select_list__ = None;
7577 let mut watermark_input_cols__ = None;
7578 let mut watermark_expr_indices__ = None;
7579 let mut nondecreasing_exprs__ = None;
7580 while let Some(k) = map_.next_key()? {
7581 match k {
7582 GeneratedField::SelectList => {
7583 if select_list__.is_some() {
7584 return Err(serde::de::Error::duplicate_field("selectList"));
7585 }
7586 select_list__ = Some(map_.next_value()?);
7587 }
7588 GeneratedField::WatermarkInputCols => {
7589 if watermark_input_cols__.is_some() {
7590 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7591 }
7592 watermark_input_cols__ =
7593 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7594 .into_iter().map(|x| x.0).collect())
7595 ;
7596 }
7597 GeneratedField::WatermarkExprIndices => {
7598 if watermark_expr_indices__.is_some() {
7599 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
7600 }
7601 watermark_expr_indices__ =
7602 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7603 .into_iter().map(|x| x.0).collect())
7604 ;
7605 }
7606 GeneratedField::NondecreasingExprs => {
7607 if nondecreasing_exprs__.is_some() {
7608 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7609 }
7610 nondecreasing_exprs__ =
7611 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7612 .into_iter().map(|x| x.0).collect())
7613 ;
7614 }
7615 }
7616 }
7617 Ok(ProjectSetNode {
7618 select_list: select_list__.unwrap_or_default(),
7619 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7620 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
7621 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7622 })
7623 }
7624 }
7625 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
7626 }
7627}
7628impl serde::Serialize for ResumeMutation {
7629 #[allow(deprecated)]
7630 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7631 where
7632 S: serde::Serializer,
7633 {
7634 use serde::ser::SerializeStruct;
7635 let len = 0;
7636 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
7637 struct_ser.end()
7638 }
7639}
7640impl<'de> serde::Deserialize<'de> for ResumeMutation {
7641 #[allow(deprecated)]
7642 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7643 where
7644 D: serde::Deserializer<'de>,
7645 {
7646 const FIELDS: &[&str] = &[
7647 ];
7648
7649 #[allow(clippy::enum_variant_names)]
7650 enum GeneratedField {
7651 }
7652 impl<'de> serde::Deserialize<'de> for GeneratedField {
7653 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7654 where
7655 D: serde::Deserializer<'de>,
7656 {
7657 struct GeneratedVisitor;
7658
7659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7660 type Value = GeneratedField;
7661
7662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7663 write!(formatter, "expected one of: {:?}", &FIELDS)
7664 }
7665
7666 #[allow(unused_variables)]
7667 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7668 where
7669 E: serde::de::Error,
7670 {
7671 Err(serde::de::Error::unknown_field(value, FIELDS))
7672 }
7673 }
7674 deserializer.deserialize_identifier(GeneratedVisitor)
7675 }
7676 }
7677 struct GeneratedVisitor;
7678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7679 type Value = ResumeMutation;
7680
7681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7682 formatter.write_str("struct stream_plan.ResumeMutation")
7683 }
7684
7685 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
7686 where
7687 V: serde::de::MapAccess<'de>,
7688 {
7689 while map_.next_key::<GeneratedField>()?.is_some() {
7690 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7691 }
7692 Ok(ResumeMutation {
7693 })
7694 }
7695 }
7696 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
7697 }
7698}
7699impl serde::Serialize for RowIdGenNode {
7700 #[allow(deprecated)]
7701 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7702 where
7703 S: serde::Serializer,
7704 {
7705 use serde::ser::SerializeStruct;
7706 let mut len = 0;
7707 if self.row_id_index != 0 {
7708 len += 1;
7709 }
7710 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
7711 if self.row_id_index != 0 {
7712 #[allow(clippy::needless_borrow)]
7713 #[allow(clippy::needless_borrows_for_generic_args)]
7714 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
7715 }
7716 struct_ser.end()
7717 }
7718}
7719impl<'de> serde::Deserialize<'de> for RowIdGenNode {
7720 #[allow(deprecated)]
7721 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7722 where
7723 D: serde::Deserializer<'de>,
7724 {
7725 const FIELDS: &[&str] = &[
7726 "row_id_index",
7727 "rowIdIndex",
7728 ];
7729
7730 #[allow(clippy::enum_variant_names)]
7731 enum GeneratedField {
7732 RowIdIndex,
7733 }
7734 impl<'de> serde::Deserialize<'de> for GeneratedField {
7735 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7736 where
7737 D: serde::Deserializer<'de>,
7738 {
7739 struct GeneratedVisitor;
7740
7741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7742 type Value = GeneratedField;
7743
7744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7745 write!(formatter, "expected one of: {:?}", &FIELDS)
7746 }
7747
7748 #[allow(unused_variables)]
7749 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7750 where
7751 E: serde::de::Error,
7752 {
7753 match value {
7754 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
7755 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7756 }
7757 }
7758 }
7759 deserializer.deserialize_identifier(GeneratedVisitor)
7760 }
7761 }
7762 struct GeneratedVisitor;
7763 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7764 type Value = RowIdGenNode;
7765
7766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7767 formatter.write_str("struct stream_plan.RowIdGenNode")
7768 }
7769
7770 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
7771 where
7772 V: serde::de::MapAccess<'de>,
7773 {
7774 let mut row_id_index__ = None;
7775 while let Some(k) = map_.next_key()? {
7776 match k {
7777 GeneratedField::RowIdIndex => {
7778 if row_id_index__.is_some() {
7779 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
7780 }
7781 row_id_index__ =
7782 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7783 ;
7784 }
7785 }
7786 }
7787 Ok(RowIdGenNode {
7788 row_id_index: row_id_index__.unwrap_or_default(),
7789 })
7790 }
7791 }
7792 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
7793 }
7794}
7795impl serde::Serialize for RowMergeNode {
7796 #[allow(deprecated)]
7797 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7798 where
7799 S: serde::Serializer,
7800 {
7801 use serde::ser::SerializeStruct;
7802 let mut len = 0;
7803 if self.lhs_mapping.is_some() {
7804 len += 1;
7805 }
7806 if self.rhs_mapping.is_some() {
7807 len += 1;
7808 }
7809 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
7810 if let Some(v) = self.lhs_mapping.as_ref() {
7811 struct_ser.serialize_field("lhsMapping", v)?;
7812 }
7813 if let Some(v) = self.rhs_mapping.as_ref() {
7814 struct_ser.serialize_field("rhsMapping", v)?;
7815 }
7816 struct_ser.end()
7817 }
7818}
7819impl<'de> serde::Deserialize<'de> for RowMergeNode {
7820 #[allow(deprecated)]
7821 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7822 where
7823 D: serde::Deserializer<'de>,
7824 {
7825 const FIELDS: &[&str] = &[
7826 "lhs_mapping",
7827 "lhsMapping",
7828 "rhs_mapping",
7829 "rhsMapping",
7830 ];
7831
7832 #[allow(clippy::enum_variant_names)]
7833 enum GeneratedField {
7834 LhsMapping,
7835 RhsMapping,
7836 }
7837 impl<'de> serde::Deserialize<'de> for GeneratedField {
7838 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7839 where
7840 D: serde::Deserializer<'de>,
7841 {
7842 struct GeneratedVisitor;
7843
7844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7845 type Value = GeneratedField;
7846
7847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7848 write!(formatter, "expected one of: {:?}", &FIELDS)
7849 }
7850
7851 #[allow(unused_variables)]
7852 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7853 where
7854 E: serde::de::Error,
7855 {
7856 match value {
7857 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
7858 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
7859 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7860 }
7861 }
7862 }
7863 deserializer.deserialize_identifier(GeneratedVisitor)
7864 }
7865 }
7866 struct GeneratedVisitor;
7867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7868 type Value = RowMergeNode;
7869
7870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7871 formatter.write_str("struct stream_plan.RowMergeNode")
7872 }
7873
7874 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
7875 where
7876 V: serde::de::MapAccess<'de>,
7877 {
7878 let mut lhs_mapping__ = None;
7879 let mut rhs_mapping__ = None;
7880 while let Some(k) = map_.next_key()? {
7881 match k {
7882 GeneratedField::LhsMapping => {
7883 if lhs_mapping__.is_some() {
7884 return Err(serde::de::Error::duplicate_field("lhsMapping"));
7885 }
7886 lhs_mapping__ = map_.next_value()?;
7887 }
7888 GeneratedField::RhsMapping => {
7889 if rhs_mapping__.is_some() {
7890 return Err(serde::de::Error::duplicate_field("rhsMapping"));
7891 }
7892 rhs_mapping__ = map_.next_value()?;
7893 }
7894 }
7895 }
7896 Ok(RowMergeNode {
7897 lhs_mapping: lhs_mapping__,
7898 rhs_mapping: rhs_mapping__,
7899 })
7900 }
7901 }
7902 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
7903 }
7904}
7905impl serde::Serialize for SimpleAggNode {
7906 #[allow(deprecated)]
7907 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7908 where
7909 S: serde::Serializer,
7910 {
7911 use serde::ser::SerializeStruct;
7912 let mut len = 0;
7913 if !self.agg_calls.is_empty() {
7914 len += 1;
7915 }
7916 if !self.distribution_key.is_empty() {
7917 len += 1;
7918 }
7919 if !self.agg_call_states.is_empty() {
7920 len += 1;
7921 }
7922 if self.intermediate_state_table.is_some() {
7923 len += 1;
7924 }
7925 if self.is_append_only {
7926 len += 1;
7927 }
7928 if !self.distinct_dedup_tables.is_empty() {
7929 len += 1;
7930 }
7931 if self.row_count_index != 0 {
7932 len += 1;
7933 }
7934 if self.version != 0 {
7935 len += 1;
7936 }
7937 if self.must_output_per_barrier {
7938 len += 1;
7939 }
7940 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
7941 if !self.agg_calls.is_empty() {
7942 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
7943 }
7944 if !self.distribution_key.is_empty() {
7945 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
7946 }
7947 if !self.agg_call_states.is_empty() {
7948 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
7949 }
7950 if let Some(v) = self.intermediate_state_table.as_ref() {
7951 struct_ser.serialize_field("intermediateStateTable", v)?;
7952 }
7953 if self.is_append_only {
7954 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
7955 }
7956 if !self.distinct_dedup_tables.is_empty() {
7957 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
7958 }
7959 if self.row_count_index != 0 {
7960 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
7961 }
7962 if self.version != 0 {
7963 let v = AggNodeVersion::try_from(self.version)
7964 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
7965 struct_ser.serialize_field("version", &v)?;
7966 }
7967 if self.must_output_per_barrier {
7968 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
7969 }
7970 struct_ser.end()
7971 }
7972}
7973impl<'de> serde::Deserialize<'de> for SimpleAggNode {
7974 #[allow(deprecated)]
7975 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7976 where
7977 D: serde::Deserializer<'de>,
7978 {
7979 const FIELDS: &[&str] = &[
7980 "agg_calls",
7981 "aggCalls",
7982 "distribution_key",
7983 "distributionKey",
7984 "agg_call_states",
7985 "aggCallStates",
7986 "intermediate_state_table",
7987 "intermediateStateTable",
7988 "is_append_only",
7989 "isAppendOnly",
7990 "distinct_dedup_tables",
7991 "distinctDedupTables",
7992 "row_count_index",
7993 "rowCountIndex",
7994 "version",
7995 "must_output_per_barrier",
7996 "mustOutputPerBarrier",
7997 ];
7998
7999 #[allow(clippy::enum_variant_names)]
8000 enum GeneratedField {
8001 AggCalls,
8002 DistributionKey,
8003 AggCallStates,
8004 IntermediateStateTable,
8005 IsAppendOnly,
8006 DistinctDedupTables,
8007 RowCountIndex,
8008 Version,
8009 MustOutputPerBarrier,
8010 }
8011 impl<'de> serde::Deserialize<'de> for GeneratedField {
8012 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8013 where
8014 D: serde::Deserializer<'de>,
8015 {
8016 struct GeneratedVisitor;
8017
8018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8019 type Value = GeneratedField;
8020
8021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8022 write!(formatter, "expected one of: {:?}", &FIELDS)
8023 }
8024
8025 #[allow(unused_variables)]
8026 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8027 where
8028 E: serde::de::Error,
8029 {
8030 match value {
8031 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8032 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8033 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8034 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8035 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8036 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8037 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8038 "version" => Ok(GeneratedField::Version),
8039 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8040 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8041 }
8042 }
8043 }
8044 deserializer.deserialize_identifier(GeneratedVisitor)
8045 }
8046 }
8047 struct GeneratedVisitor;
8048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8049 type Value = SimpleAggNode;
8050
8051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8052 formatter.write_str("struct stream_plan.SimpleAggNode")
8053 }
8054
8055 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8056 where
8057 V: serde::de::MapAccess<'de>,
8058 {
8059 let mut agg_calls__ = None;
8060 let mut distribution_key__ = None;
8061 let mut agg_call_states__ = None;
8062 let mut intermediate_state_table__ = None;
8063 let mut is_append_only__ = None;
8064 let mut distinct_dedup_tables__ = None;
8065 let mut row_count_index__ = None;
8066 let mut version__ = None;
8067 let mut must_output_per_barrier__ = None;
8068 while let Some(k) = map_.next_key()? {
8069 match k {
8070 GeneratedField::AggCalls => {
8071 if agg_calls__.is_some() {
8072 return Err(serde::de::Error::duplicate_field("aggCalls"));
8073 }
8074 agg_calls__ = Some(map_.next_value()?);
8075 }
8076 GeneratedField::DistributionKey => {
8077 if distribution_key__.is_some() {
8078 return Err(serde::de::Error::duplicate_field("distributionKey"));
8079 }
8080 distribution_key__ =
8081 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8082 .into_iter().map(|x| x.0).collect())
8083 ;
8084 }
8085 GeneratedField::AggCallStates => {
8086 if agg_call_states__.is_some() {
8087 return Err(serde::de::Error::duplicate_field("aggCallStates"));
8088 }
8089 agg_call_states__ = Some(map_.next_value()?);
8090 }
8091 GeneratedField::IntermediateStateTable => {
8092 if intermediate_state_table__.is_some() {
8093 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8094 }
8095 intermediate_state_table__ = map_.next_value()?;
8096 }
8097 GeneratedField::IsAppendOnly => {
8098 if is_append_only__.is_some() {
8099 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8100 }
8101 is_append_only__ = Some(map_.next_value()?);
8102 }
8103 GeneratedField::DistinctDedupTables => {
8104 if distinct_dedup_tables__.is_some() {
8105 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8106 }
8107 distinct_dedup_tables__ = Some(
8108 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8109 .into_iter().map(|(k,v)| (k.0, v)).collect()
8110 );
8111 }
8112 GeneratedField::RowCountIndex => {
8113 if row_count_index__.is_some() {
8114 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8115 }
8116 row_count_index__ =
8117 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8118 ;
8119 }
8120 GeneratedField::Version => {
8121 if version__.is_some() {
8122 return Err(serde::de::Error::duplicate_field("version"));
8123 }
8124 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8125 }
8126 GeneratedField::MustOutputPerBarrier => {
8127 if must_output_per_barrier__.is_some() {
8128 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8129 }
8130 must_output_per_barrier__ = Some(map_.next_value()?);
8131 }
8132 }
8133 }
8134 Ok(SimpleAggNode {
8135 agg_calls: agg_calls__.unwrap_or_default(),
8136 distribution_key: distribution_key__.unwrap_or_default(),
8137 agg_call_states: agg_call_states__.unwrap_or_default(),
8138 intermediate_state_table: intermediate_state_table__,
8139 is_append_only: is_append_only__.unwrap_or_default(),
8140 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8141 row_count_index: row_count_index__.unwrap_or_default(),
8142 version: version__.unwrap_or_default(),
8143 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8144 })
8145 }
8146 }
8147 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8148 }
8149}
8150impl serde::Serialize for SinkDesc {
8151 #[allow(deprecated)]
8152 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8153 where
8154 S: serde::Serializer,
8155 {
8156 use serde::ser::SerializeStruct;
8157 let mut len = 0;
8158 if self.id != 0 {
8159 len += 1;
8160 }
8161 if !self.name.is_empty() {
8162 len += 1;
8163 }
8164 if !self.definition.is_empty() {
8165 len += 1;
8166 }
8167 if !self.plan_pk.is_empty() {
8168 len += 1;
8169 }
8170 if !self.downstream_pk.is_empty() {
8171 len += 1;
8172 }
8173 if !self.distribution_key.is_empty() {
8174 len += 1;
8175 }
8176 if !self.properties.is_empty() {
8177 len += 1;
8178 }
8179 if self.sink_type != 0 {
8180 len += 1;
8181 }
8182 if !self.column_catalogs.is_empty() {
8183 len += 1;
8184 }
8185 if !self.db_name.is_empty() {
8186 len += 1;
8187 }
8188 if !self.sink_from_name.is_empty() {
8189 len += 1;
8190 }
8191 if self.format_desc.is_some() {
8192 len += 1;
8193 }
8194 if self.target_table.is_some() {
8195 len += 1;
8196 }
8197 if self.extra_partition_col_idx.is_some() {
8198 len += 1;
8199 }
8200 if !self.secret_refs.is_empty() {
8201 len += 1;
8202 }
8203 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8204 if self.id != 0 {
8205 struct_ser.serialize_field("id", &self.id)?;
8206 }
8207 if !self.name.is_empty() {
8208 struct_ser.serialize_field("name", &self.name)?;
8209 }
8210 if !self.definition.is_empty() {
8211 struct_ser.serialize_field("definition", &self.definition)?;
8212 }
8213 if !self.plan_pk.is_empty() {
8214 struct_ser.serialize_field("planPk", &self.plan_pk)?;
8215 }
8216 if !self.downstream_pk.is_empty() {
8217 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8218 }
8219 if !self.distribution_key.is_empty() {
8220 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8221 }
8222 if !self.properties.is_empty() {
8223 struct_ser.serialize_field("properties", &self.properties)?;
8224 }
8225 if self.sink_type != 0 {
8226 let v = super::catalog::SinkType::try_from(self.sink_type)
8227 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8228 struct_ser.serialize_field("sinkType", &v)?;
8229 }
8230 if !self.column_catalogs.is_empty() {
8231 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8232 }
8233 if !self.db_name.is_empty() {
8234 struct_ser.serialize_field("dbName", &self.db_name)?;
8235 }
8236 if !self.sink_from_name.is_empty() {
8237 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8238 }
8239 if let Some(v) = self.format_desc.as_ref() {
8240 struct_ser.serialize_field("formatDesc", v)?;
8241 }
8242 if let Some(v) = self.target_table.as_ref() {
8243 struct_ser.serialize_field("targetTable", v)?;
8244 }
8245 if let Some(v) = self.extra_partition_col_idx.as_ref() {
8246 #[allow(clippy::needless_borrow)]
8247 #[allow(clippy::needless_borrows_for_generic_args)]
8248 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8249 }
8250 if !self.secret_refs.is_empty() {
8251 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8252 }
8253 struct_ser.end()
8254 }
8255}
8256impl<'de> serde::Deserialize<'de> for SinkDesc {
8257 #[allow(deprecated)]
8258 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8259 where
8260 D: serde::Deserializer<'de>,
8261 {
8262 const FIELDS: &[&str] = &[
8263 "id",
8264 "name",
8265 "definition",
8266 "plan_pk",
8267 "planPk",
8268 "downstream_pk",
8269 "downstreamPk",
8270 "distribution_key",
8271 "distributionKey",
8272 "properties",
8273 "sink_type",
8274 "sinkType",
8275 "column_catalogs",
8276 "columnCatalogs",
8277 "db_name",
8278 "dbName",
8279 "sink_from_name",
8280 "sinkFromName",
8281 "format_desc",
8282 "formatDesc",
8283 "target_table",
8284 "targetTable",
8285 "extra_partition_col_idx",
8286 "extraPartitionColIdx",
8287 "secret_refs",
8288 "secretRefs",
8289 ];
8290
8291 #[allow(clippy::enum_variant_names)]
8292 enum GeneratedField {
8293 Id,
8294 Name,
8295 Definition,
8296 PlanPk,
8297 DownstreamPk,
8298 DistributionKey,
8299 Properties,
8300 SinkType,
8301 ColumnCatalogs,
8302 DbName,
8303 SinkFromName,
8304 FormatDesc,
8305 TargetTable,
8306 ExtraPartitionColIdx,
8307 SecretRefs,
8308 }
8309 impl<'de> serde::Deserialize<'de> for GeneratedField {
8310 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8311 where
8312 D: serde::Deserializer<'de>,
8313 {
8314 struct GeneratedVisitor;
8315
8316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8317 type Value = GeneratedField;
8318
8319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8320 write!(formatter, "expected one of: {:?}", &FIELDS)
8321 }
8322
8323 #[allow(unused_variables)]
8324 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8325 where
8326 E: serde::de::Error,
8327 {
8328 match value {
8329 "id" => Ok(GeneratedField::Id),
8330 "name" => Ok(GeneratedField::Name),
8331 "definition" => Ok(GeneratedField::Definition),
8332 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
8333 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
8334 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8335 "properties" => Ok(GeneratedField::Properties),
8336 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
8337 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
8338 "dbName" | "db_name" => Ok(GeneratedField::DbName),
8339 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
8340 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
8341 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
8342 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
8343 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
8344 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8345 }
8346 }
8347 }
8348 deserializer.deserialize_identifier(GeneratedVisitor)
8349 }
8350 }
8351 struct GeneratedVisitor;
8352 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8353 type Value = SinkDesc;
8354
8355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8356 formatter.write_str("struct stream_plan.SinkDesc")
8357 }
8358
8359 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
8360 where
8361 V: serde::de::MapAccess<'de>,
8362 {
8363 let mut id__ = None;
8364 let mut name__ = None;
8365 let mut definition__ = None;
8366 let mut plan_pk__ = None;
8367 let mut downstream_pk__ = None;
8368 let mut distribution_key__ = None;
8369 let mut properties__ = None;
8370 let mut sink_type__ = None;
8371 let mut column_catalogs__ = None;
8372 let mut db_name__ = None;
8373 let mut sink_from_name__ = None;
8374 let mut format_desc__ = None;
8375 let mut target_table__ = None;
8376 let mut extra_partition_col_idx__ = None;
8377 let mut secret_refs__ = None;
8378 while let Some(k) = map_.next_key()? {
8379 match k {
8380 GeneratedField::Id => {
8381 if id__.is_some() {
8382 return Err(serde::de::Error::duplicate_field("id"));
8383 }
8384 id__ =
8385 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8386 ;
8387 }
8388 GeneratedField::Name => {
8389 if name__.is_some() {
8390 return Err(serde::de::Error::duplicate_field("name"));
8391 }
8392 name__ = Some(map_.next_value()?);
8393 }
8394 GeneratedField::Definition => {
8395 if definition__.is_some() {
8396 return Err(serde::de::Error::duplicate_field("definition"));
8397 }
8398 definition__ = Some(map_.next_value()?);
8399 }
8400 GeneratedField::PlanPk => {
8401 if plan_pk__.is_some() {
8402 return Err(serde::de::Error::duplicate_field("planPk"));
8403 }
8404 plan_pk__ = Some(map_.next_value()?);
8405 }
8406 GeneratedField::DownstreamPk => {
8407 if downstream_pk__.is_some() {
8408 return Err(serde::de::Error::duplicate_field("downstreamPk"));
8409 }
8410 downstream_pk__ =
8411 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8412 .into_iter().map(|x| x.0).collect())
8413 ;
8414 }
8415 GeneratedField::DistributionKey => {
8416 if distribution_key__.is_some() {
8417 return Err(serde::de::Error::duplicate_field("distributionKey"));
8418 }
8419 distribution_key__ =
8420 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8421 .into_iter().map(|x| x.0).collect())
8422 ;
8423 }
8424 GeneratedField::Properties => {
8425 if properties__.is_some() {
8426 return Err(serde::de::Error::duplicate_field("properties"));
8427 }
8428 properties__ = Some(
8429 map_.next_value::<std::collections::BTreeMap<_, _>>()?
8430 );
8431 }
8432 GeneratedField::SinkType => {
8433 if sink_type__.is_some() {
8434 return Err(serde::de::Error::duplicate_field("sinkType"));
8435 }
8436 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
8437 }
8438 GeneratedField::ColumnCatalogs => {
8439 if column_catalogs__.is_some() {
8440 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
8441 }
8442 column_catalogs__ = Some(map_.next_value()?);
8443 }
8444 GeneratedField::DbName => {
8445 if db_name__.is_some() {
8446 return Err(serde::de::Error::duplicate_field("dbName"));
8447 }
8448 db_name__ = Some(map_.next_value()?);
8449 }
8450 GeneratedField::SinkFromName => {
8451 if sink_from_name__.is_some() {
8452 return Err(serde::de::Error::duplicate_field("sinkFromName"));
8453 }
8454 sink_from_name__ = Some(map_.next_value()?);
8455 }
8456 GeneratedField::FormatDesc => {
8457 if format_desc__.is_some() {
8458 return Err(serde::de::Error::duplicate_field("formatDesc"));
8459 }
8460 format_desc__ = map_.next_value()?;
8461 }
8462 GeneratedField::TargetTable => {
8463 if target_table__.is_some() {
8464 return Err(serde::de::Error::duplicate_field("targetTable"));
8465 }
8466 target_table__ =
8467 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8468 ;
8469 }
8470 GeneratedField::ExtraPartitionColIdx => {
8471 if extra_partition_col_idx__.is_some() {
8472 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
8473 }
8474 extra_partition_col_idx__ =
8475 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8476 ;
8477 }
8478 GeneratedField::SecretRefs => {
8479 if secret_refs__.is_some() {
8480 return Err(serde::de::Error::duplicate_field("secretRefs"));
8481 }
8482 secret_refs__ = Some(
8483 map_.next_value::<std::collections::BTreeMap<_, _>>()?
8484 );
8485 }
8486 }
8487 }
8488 Ok(SinkDesc {
8489 id: id__.unwrap_or_default(),
8490 name: name__.unwrap_or_default(),
8491 definition: definition__.unwrap_or_default(),
8492 plan_pk: plan_pk__.unwrap_or_default(),
8493 downstream_pk: downstream_pk__.unwrap_or_default(),
8494 distribution_key: distribution_key__.unwrap_or_default(),
8495 properties: properties__.unwrap_or_default(),
8496 sink_type: sink_type__.unwrap_or_default(),
8497 column_catalogs: column_catalogs__.unwrap_or_default(),
8498 db_name: db_name__.unwrap_or_default(),
8499 sink_from_name: sink_from_name__.unwrap_or_default(),
8500 format_desc: format_desc__,
8501 target_table: target_table__,
8502 extra_partition_col_idx: extra_partition_col_idx__,
8503 secret_refs: secret_refs__.unwrap_or_default(),
8504 })
8505 }
8506 }
8507 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
8508 }
8509}
8510impl serde::Serialize for SinkLogStoreType {
8511 #[allow(deprecated)]
8512 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8513 where
8514 S: serde::Serializer,
8515 {
8516 let variant = match self {
8517 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8518 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8519 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8520 };
8521 serializer.serialize_str(variant)
8522 }
8523}
8524impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
8525 #[allow(deprecated)]
8526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8527 where
8528 D: serde::Deserializer<'de>,
8529 {
8530 const FIELDS: &[&str] = &[
8531 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8532 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8533 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8534 ];
8535
8536 struct GeneratedVisitor;
8537
8538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8539 type Value = SinkLogStoreType;
8540
8541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8542 write!(formatter, "expected one of: {:?}", &FIELDS)
8543 }
8544
8545 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8546 where
8547 E: serde::de::Error,
8548 {
8549 i32::try_from(v)
8550 .ok()
8551 .and_then(|x| x.try_into().ok())
8552 .ok_or_else(|| {
8553 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8554 })
8555 }
8556
8557 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8558 where
8559 E: serde::de::Error,
8560 {
8561 i32::try_from(v)
8562 .ok()
8563 .and_then(|x| x.try_into().ok())
8564 .ok_or_else(|| {
8565 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8566 })
8567 }
8568
8569 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8570 where
8571 E: serde::de::Error,
8572 {
8573 match value {
8574 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
8575 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
8576 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
8577 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8578 }
8579 }
8580 }
8581 deserializer.deserialize_any(GeneratedVisitor)
8582 }
8583}
8584impl serde::Serialize for SinkNode {
8585 #[allow(deprecated)]
8586 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8587 where
8588 S: serde::Serializer,
8589 {
8590 use serde::ser::SerializeStruct;
8591 let mut len = 0;
8592 if self.sink_desc.is_some() {
8593 len += 1;
8594 }
8595 if self.table.is_some() {
8596 len += 1;
8597 }
8598 if self.log_store_type != 0 {
8599 len += 1;
8600 }
8601 if self.rate_limit.is_some() {
8602 len += 1;
8603 }
8604 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
8605 if let Some(v) = self.sink_desc.as_ref() {
8606 struct_ser.serialize_field("sinkDesc", v)?;
8607 }
8608 if let Some(v) = self.table.as_ref() {
8609 struct_ser.serialize_field("table", v)?;
8610 }
8611 if self.log_store_type != 0 {
8612 let v = SinkLogStoreType::try_from(self.log_store_type)
8613 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
8614 struct_ser.serialize_field("logStoreType", &v)?;
8615 }
8616 if let Some(v) = self.rate_limit.as_ref() {
8617 struct_ser.serialize_field("rateLimit", v)?;
8618 }
8619 struct_ser.end()
8620 }
8621}
8622impl<'de> serde::Deserialize<'de> for SinkNode {
8623 #[allow(deprecated)]
8624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8625 where
8626 D: serde::Deserializer<'de>,
8627 {
8628 const FIELDS: &[&str] = &[
8629 "sink_desc",
8630 "sinkDesc",
8631 "table",
8632 "log_store_type",
8633 "logStoreType",
8634 "rate_limit",
8635 "rateLimit",
8636 ];
8637
8638 #[allow(clippy::enum_variant_names)]
8639 enum GeneratedField {
8640 SinkDesc,
8641 Table,
8642 LogStoreType,
8643 RateLimit,
8644 }
8645 impl<'de> serde::Deserialize<'de> for GeneratedField {
8646 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8647 where
8648 D: serde::Deserializer<'de>,
8649 {
8650 struct GeneratedVisitor;
8651
8652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8653 type Value = GeneratedField;
8654
8655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8656 write!(formatter, "expected one of: {:?}", &FIELDS)
8657 }
8658
8659 #[allow(unused_variables)]
8660 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8661 where
8662 E: serde::de::Error,
8663 {
8664 match value {
8665 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
8666 "table" => Ok(GeneratedField::Table),
8667 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
8668 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8669 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8670 }
8671 }
8672 }
8673 deserializer.deserialize_identifier(GeneratedVisitor)
8674 }
8675 }
8676 struct GeneratedVisitor;
8677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8678 type Value = SinkNode;
8679
8680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8681 formatter.write_str("struct stream_plan.SinkNode")
8682 }
8683
8684 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
8685 where
8686 V: serde::de::MapAccess<'de>,
8687 {
8688 let mut sink_desc__ = None;
8689 let mut table__ = None;
8690 let mut log_store_type__ = None;
8691 let mut rate_limit__ = None;
8692 while let Some(k) = map_.next_key()? {
8693 match k {
8694 GeneratedField::SinkDesc => {
8695 if sink_desc__.is_some() {
8696 return Err(serde::de::Error::duplicate_field("sinkDesc"));
8697 }
8698 sink_desc__ = map_.next_value()?;
8699 }
8700 GeneratedField::Table => {
8701 if table__.is_some() {
8702 return Err(serde::de::Error::duplicate_field("table"));
8703 }
8704 table__ = map_.next_value()?;
8705 }
8706 GeneratedField::LogStoreType => {
8707 if log_store_type__.is_some() {
8708 return Err(serde::de::Error::duplicate_field("logStoreType"));
8709 }
8710 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
8711 }
8712 GeneratedField::RateLimit => {
8713 if rate_limit__.is_some() {
8714 return Err(serde::de::Error::duplicate_field("rateLimit"));
8715 }
8716 rate_limit__ =
8717 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8718 ;
8719 }
8720 }
8721 }
8722 Ok(SinkNode {
8723 sink_desc: sink_desc__,
8724 table: table__,
8725 log_store_type: log_store_type__.unwrap_or_default(),
8726 rate_limit: rate_limit__,
8727 })
8728 }
8729 }
8730 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
8731 }
8732}
8733impl serde::Serialize for SortNode {
8734 #[allow(deprecated)]
8735 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8736 where
8737 S: serde::Serializer,
8738 {
8739 use serde::ser::SerializeStruct;
8740 let mut len = 0;
8741 if self.state_table.is_some() {
8742 len += 1;
8743 }
8744 if self.sort_column_index != 0 {
8745 len += 1;
8746 }
8747 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
8748 if let Some(v) = self.state_table.as_ref() {
8749 struct_ser.serialize_field("stateTable", v)?;
8750 }
8751 if self.sort_column_index != 0 {
8752 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
8753 }
8754 struct_ser.end()
8755 }
8756}
8757impl<'de> serde::Deserialize<'de> for SortNode {
8758 #[allow(deprecated)]
8759 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8760 where
8761 D: serde::Deserializer<'de>,
8762 {
8763 const FIELDS: &[&str] = &[
8764 "state_table",
8765 "stateTable",
8766 "sort_column_index",
8767 "sortColumnIndex",
8768 ];
8769
8770 #[allow(clippy::enum_variant_names)]
8771 enum GeneratedField {
8772 StateTable,
8773 SortColumnIndex,
8774 }
8775 impl<'de> serde::Deserialize<'de> for GeneratedField {
8776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8777 where
8778 D: serde::Deserializer<'de>,
8779 {
8780 struct GeneratedVisitor;
8781
8782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8783 type Value = GeneratedField;
8784
8785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8786 write!(formatter, "expected one of: {:?}", &FIELDS)
8787 }
8788
8789 #[allow(unused_variables)]
8790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8791 where
8792 E: serde::de::Error,
8793 {
8794 match value {
8795 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8796 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
8797 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8798 }
8799 }
8800 }
8801 deserializer.deserialize_identifier(GeneratedVisitor)
8802 }
8803 }
8804 struct GeneratedVisitor;
8805 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8806 type Value = SortNode;
8807
8808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8809 formatter.write_str("struct stream_plan.SortNode")
8810 }
8811
8812 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
8813 where
8814 V: serde::de::MapAccess<'de>,
8815 {
8816 let mut state_table__ = None;
8817 let mut sort_column_index__ = None;
8818 while let Some(k) = map_.next_key()? {
8819 match k {
8820 GeneratedField::StateTable => {
8821 if state_table__.is_some() {
8822 return Err(serde::de::Error::duplicate_field("stateTable"));
8823 }
8824 state_table__ = map_.next_value()?;
8825 }
8826 GeneratedField::SortColumnIndex => {
8827 if sort_column_index__.is_some() {
8828 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
8829 }
8830 sort_column_index__ =
8831 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8832 ;
8833 }
8834 }
8835 }
8836 Ok(SortNode {
8837 state_table: state_table__,
8838 sort_column_index: sort_column_index__.unwrap_or_default(),
8839 })
8840 }
8841 }
8842 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
8843 }
8844}
8845impl serde::Serialize for SourceBackfillNode {
8846 #[allow(deprecated)]
8847 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8848 where
8849 S: serde::Serializer,
8850 {
8851 use serde::ser::SerializeStruct;
8852 let mut len = 0;
8853 if self.upstream_source_id != 0 {
8854 len += 1;
8855 }
8856 if self.row_id_index.is_some() {
8857 len += 1;
8858 }
8859 if !self.columns.is_empty() {
8860 len += 1;
8861 }
8862 if self.info.is_some() {
8863 len += 1;
8864 }
8865 if !self.source_name.is_empty() {
8866 len += 1;
8867 }
8868 if !self.with_properties.is_empty() {
8869 len += 1;
8870 }
8871 if self.rate_limit.is_some() {
8872 len += 1;
8873 }
8874 if self.state_table.is_some() {
8875 len += 1;
8876 }
8877 if !self.secret_refs.is_empty() {
8878 len += 1;
8879 }
8880 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
8881 if self.upstream_source_id != 0 {
8882 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
8883 }
8884 if let Some(v) = self.row_id_index.as_ref() {
8885 struct_ser.serialize_field("rowIdIndex", v)?;
8886 }
8887 if !self.columns.is_empty() {
8888 struct_ser.serialize_field("columns", &self.columns)?;
8889 }
8890 if let Some(v) = self.info.as_ref() {
8891 struct_ser.serialize_field("info", v)?;
8892 }
8893 if !self.source_name.is_empty() {
8894 struct_ser.serialize_field("sourceName", &self.source_name)?;
8895 }
8896 if !self.with_properties.is_empty() {
8897 struct_ser.serialize_field("withProperties", &self.with_properties)?;
8898 }
8899 if let Some(v) = self.rate_limit.as_ref() {
8900 struct_ser.serialize_field("rateLimit", v)?;
8901 }
8902 if let Some(v) = self.state_table.as_ref() {
8903 struct_ser.serialize_field("stateTable", v)?;
8904 }
8905 if !self.secret_refs.is_empty() {
8906 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8907 }
8908 struct_ser.end()
8909 }
8910}
8911impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
8912 #[allow(deprecated)]
8913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8914 where
8915 D: serde::Deserializer<'de>,
8916 {
8917 const FIELDS: &[&str] = &[
8918 "upstream_source_id",
8919 "upstreamSourceId",
8920 "row_id_index",
8921 "rowIdIndex",
8922 "columns",
8923 "info",
8924 "source_name",
8925 "sourceName",
8926 "with_properties",
8927 "withProperties",
8928 "rate_limit",
8929 "rateLimit",
8930 "state_table",
8931 "stateTable",
8932 "secret_refs",
8933 "secretRefs",
8934 ];
8935
8936 #[allow(clippy::enum_variant_names)]
8937 enum GeneratedField {
8938 UpstreamSourceId,
8939 RowIdIndex,
8940 Columns,
8941 Info,
8942 SourceName,
8943 WithProperties,
8944 RateLimit,
8945 StateTable,
8946 SecretRefs,
8947 }
8948 impl<'de> serde::Deserialize<'de> for GeneratedField {
8949 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8950 where
8951 D: serde::Deserializer<'de>,
8952 {
8953 struct GeneratedVisitor;
8954
8955 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8956 type Value = GeneratedField;
8957
8958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8959 write!(formatter, "expected one of: {:?}", &FIELDS)
8960 }
8961
8962 #[allow(unused_variables)]
8963 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8964 where
8965 E: serde::de::Error,
8966 {
8967 match value {
8968 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
8969 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8970 "columns" => Ok(GeneratedField::Columns),
8971 "info" => Ok(GeneratedField::Info),
8972 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
8973 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
8974 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8975 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8976 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
8977 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8978 }
8979 }
8980 }
8981 deserializer.deserialize_identifier(GeneratedVisitor)
8982 }
8983 }
8984 struct GeneratedVisitor;
8985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8986 type Value = SourceBackfillNode;
8987
8988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8989 formatter.write_str("struct stream_plan.SourceBackfillNode")
8990 }
8991
8992 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
8993 where
8994 V: serde::de::MapAccess<'de>,
8995 {
8996 let mut upstream_source_id__ = None;
8997 let mut row_id_index__ = None;
8998 let mut columns__ = None;
8999 let mut info__ = None;
9000 let mut source_name__ = None;
9001 let mut with_properties__ = None;
9002 let mut rate_limit__ = None;
9003 let mut state_table__ = None;
9004 let mut secret_refs__ = None;
9005 while let Some(k) = map_.next_key()? {
9006 match k {
9007 GeneratedField::UpstreamSourceId => {
9008 if upstream_source_id__.is_some() {
9009 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9010 }
9011 upstream_source_id__ =
9012 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9013 ;
9014 }
9015 GeneratedField::RowIdIndex => {
9016 if row_id_index__.is_some() {
9017 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9018 }
9019 row_id_index__ =
9020 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9021 ;
9022 }
9023 GeneratedField::Columns => {
9024 if columns__.is_some() {
9025 return Err(serde::de::Error::duplicate_field("columns"));
9026 }
9027 columns__ = Some(map_.next_value()?);
9028 }
9029 GeneratedField::Info => {
9030 if info__.is_some() {
9031 return Err(serde::de::Error::duplicate_field("info"));
9032 }
9033 info__ = map_.next_value()?;
9034 }
9035 GeneratedField::SourceName => {
9036 if source_name__.is_some() {
9037 return Err(serde::de::Error::duplicate_field("sourceName"));
9038 }
9039 source_name__ = Some(map_.next_value()?);
9040 }
9041 GeneratedField::WithProperties => {
9042 if with_properties__.is_some() {
9043 return Err(serde::de::Error::duplicate_field("withProperties"));
9044 }
9045 with_properties__ = Some(
9046 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9047 );
9048 }
9049 GeneratedField::RateLimit => {
9050 if rate_limit__.is_some() {
9051 return Err(serde::de::Error::duplicate_field("rateLimit"));
9052 }
9053 rate_limit__ =
9054 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9055 ;
9056 }
9057 GeneratedField::StateTable => {
9058 if state_table__.is_some() {
9059 return Err(serde::de::Error::duplicate_field("stateTable"));
9060 }
9061 state_table__ = map_.next_value()?;
9062 }
9063 GeneratedField::SecretRefs => {
9064 if secret_refs__.is_some() {
9065 return Err(serde::de::Error::duplicate_field("secretRefs"));
9066 }
9067 secret_refs__ = Some(
9068 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9069 );
9070 }
9071 }
9072 }
9073 Ok(SourceBackfillNode {
9074 upstream_source_id: upstream_source_id__.unwrap_or_default(),
9075 row_id_index: row_id_index__,
9076 columns: columns__.unwrap_or_default(),
9077 info: info__,
9078 source_name: source_name__.unwrap_or_default(),
9079 with_properties: with_properties__.unwrap_or_default(),
9080 rate_limit: rate_limit__,
9081 state_table: state_table__,
9082 secret_refs: secret_refs__.unwrap_or_default(),
9083 })
9084 }
9085 }
9086 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9087 }
9088}
9089impl serde::Serialize for SourceChangeSplitMutation {
9090 #[allow(deprecated)]
9091 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9092 where
9093 S: serde::Serializer,
9094 {
9095 use serde::ser::SerializeStruct;
9096 let mut len = 0;
9097 if !self.actor_splits.is_empty() {
9098 len += 1;
9099 }
9100 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9101 if !self.actor_splits.is_empty() {
9102 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9103 }
9104 struct_ser.end()
9105 }
9106}
9107impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9108 #[allow(deprecated)]
9109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9110 where
9111 D: serde::Deserializer<'de>,
9112 {
9113 const FIELDS: &[&str] = &[
9114 "actor_splits",
9115 "actorSplits",
9116 ];
9117
9118 #[allow(clippy::enum_variant_names)]
9119 enum GeneratedField {
9120 ActorSplits,
9121 }
9122 impl<'de> serde::Deserialize<'de> for GeneratedField {
9123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9124 where
9125 D: serde::Deserializer<'de>,
9126 {
9127 struct GeneratedVisitor;
9128
9129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9130 type Value = GeneratedField;
9131
9132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9133 write!(formatter, "expected one of: {:?}", &FIELDS)
9134 }
9135
9136 #[allow(unused_variables)]
9137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9138 where
9139 E: serde::de::Error,
9140 {
9141 match value {
9142 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9144 }
9145 }
9146 }
9147 deserializer.deserialize_identifier(GeneratedVisitor)
9148 }
9149 }
9150 struct GeneratedVisitor;
9151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9152 type Value = SourceChangeSplitMutation;
9153
9154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9155 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9156 }
9157
9158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9159 where
9160 V: serde::de::MapAccess<'de>,
9161 {
9162 let mut actor_splits__ = None;
9163 while let Some(k) = map_.next_key()? {
9164 match k {
9165 GeneratedField::ActorSplits => {
9166 if actor_splits__.is_some() {
9167 return Err(serde::de::Error::duplicate_field("actorSplits"));
9168 }
9169 actor_splits__ = Some(
9170 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9171 .into_iter().map(|(k,v)| (k.0, v)).collect()
9172 );
9173 }
9174 }
9175 }
9176 Ok(SourceChangeSplitMutation {
9177 actor_splits: actor_splits__.unwrap_or_default(),
9178 })
9179 }
9180 }
9181 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9182 }
9183}
9184impl serde::Serialize for SourceNode {
9185 #[allow(deprecated)]
9186 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9187 where
9188 S: serde::Serializer,
9189 {
9190 use serde::ser::SerializeStruct;
9191 let mut len = 0;
9192 if self.source_inner.is_some() {
9193 len += 1;
9194 }
9195 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9196 if let Some(v) = self.source_inner.as_ref() {
9197 struct_ser.serialize_field("sourceInner", v)?;
9198 }
9199 struct_ser.end()
9200 }
9201}
9202impl<'de> serde::Deserialize<'de> for SourceNode {
9203 #[allow(deprecated)]
9204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9205 where
9206 D: serde::Deserializer<'de>,
9207 {
9208 const FIELDS: &[&str] = &[
9209 "source_inner",
9210 "sourceInner",
9211 ];
9212
9213 #[allow(clippy::enum_variant_names)]
9214 enum GeneratedField {
9215 SourceInner,
9216 }
9217 impl<'de> serde::Deserialize<'de> for GeneratedField {
9218 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9219 where
9220 D: serde::Deserializer<'de>,
9221 {
9222 struct GeneratedVisitor;
9223
9224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9225 type Value = GeneratedField;
9226
9227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9228 write!(formatter, "expected one of: {:?}", &FIELDS)
9229 }
9230
9231 #[allow(unused_variables)]
9232 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9233 where
9234 E: serde::de::Error,
9235 {
9236 match value {
9237 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9238 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9239 }
9240 }
9241 }
9242 deserializer.deserialize_identifier(GeneratedVisitor)
9243 }
9244 }
9245 struct GeneratedVisitor;
9246 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9247 type Value = SourceNode;
9248
9249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9250 formatter.write_str("struct stream_plan.SourceNode")
9251 }
9252
9253 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9254 where
9255 V: serde::de::MapAccess<'de>,
9256 {
9257 let mut source_inner__ = None;
9258 while let Some(k) = map_.next_key()? {
9259 match k {
9260 GeneratedField::SourceInner => {
9261 if source_inner__.is_some() {
9262 return Err(serde::de::Error::duplicate_field("sourceInner"));
9263 }
9264 source_inner__ = map_.next_value()?;
9265 }
9266 }
9267 }
9268 Ok(SourceNode {
9269 source_inner: source_inner__,
9270 })
9271 }
9272 }
9273 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
9274 }
9275}
9276impl serde::Serialize for StartFragmentBackfillMutation {
9277 #[allow(deprecated)]
9278 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9279 where
9280 S: serde::Serializer,
9281 {
9282 use serde::ser::SerializeStruct;
9283 let mut len = 0;
9284 if !self.fragment_ids.is_empty() {
9285 len += 1;
9286 }
9287 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
9288 if !self.fragment_ids.is_empty() {
9289 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
9290 }
9291 struct_ser.end()
9292 }
9293}
9294impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
9295 #[allow(deprecated)]
9296 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9297 where
9298 D: serde::Deserializer<'de>,
9299 {
9300 const FIELDS: &[&str] = &[
9301 "fragment_ids",
9302 "fragmentIds",
9303 ];
9304
9305 #[allow(clippy::enum_variant_names)]
9306 enum GeneratedField {
9307 FragmentIds,
9308 }
9309 impl<'de> serde::Deserialize<'de> for GeneratedField {
9310 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9311 where
9312 D: serde::Deserializer<'de>,
9313 {
9314 struct GeneratedVisitor;
9315
9316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9317 type Value = GeneratedField;
9318
9319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9320 write!(formatter, "expected one of: {:?}", &FIELDS)
9321 }
9322
9323 #[allow(unused_variables)]
9324 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9325 where
9326 E: serde::de::Error,
9327 {
9328 match value {
9329 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
9330 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9331 }
9332 }
9333 }
9334 deserializer.deserialize_identifier(GeneratedVisitor)
9335 }
9336 }
9337 struct GeneratedVisitor;
9338 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9339 type Value = StartFragmentBackfillMutation;
9340
9341 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9342 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
9343 }
9344
9345 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
9346 where
9347 V: serde::de::MapAccess<'de>,
9348 {
9349 let mut fragment_ids__ = None;
9350 while let Some(k) = map_.next_key()? {
9351 match k {
9352 GeneratedField::FragmentIds => {
9353 if fragment_ids__.is_some() {
9354 return Err(serde::de::Error::duplicate_field("fragmentIds"));
9355 }
9356 fragment_ids__ =
9357 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9358 .into_iter().map(|x| x.0).collect())
9359 ;
9360 }
9361 }
9362 }
9363 Ok(StartFragmentBackfillMutation {
9364 fragment_ids: fragment_ids__.unwrap_or_default(),
9365 })
9366 }
9367 }
9368 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
9369 }
9370}
9371impl serde::Serialize for StopMutation {
9372 #[allow(deprecated)]
9373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9374 where
9375 S: serde::Serializer,
9376 {
9377 use serde::ser::SerializeStruct;
9378 let mut len = 0;
9379 if !self.actors.is_empty() {
9380 len += 1;
9381 }
9382 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
9383 if !self.actors.is_empty() {
9384 struct_ser.serialize_field("actors", &self.actors)?;
9385 }
9386 struct_ser.end()
9387 }
9388}
9389impl<'de> serde::Deserialize<'de> for StopMutation {
9390 #[allow(deprecated)]
9391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9392 where
9393 D: serde::Deserializer<'de>,
9394 {
9395 const FIELDS: &[&str] = &[
9396 "actors",
9397 ];
9398
9399 #[allow(clippy::enum_variant_names)]
9400 enum GeneratedField {
9401 Actors,
9402 }
9403 impl<'de> serde::Deserialize<'de> for GeneratedField {
9404 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9405 where
9406 D: serde::Deserializer<'de>,
9407 {
9408 struct GeneratedVisitor;
9409
9410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9411 type Value = GeneratedField;
9412
9413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9414 write!(formatter, "expected one of: {:?}", &FIELDS)
9415 }
9416
9417 #[allow(unused_variables)]
9418 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9419 where
9420 E: serde::de::Error,
9421 {
9422 match value {
9423 "actors" => Ok(GeneratedField::Actors),
9424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9425 }
9426 }
9427 }
9428 deserializer.deserialize_identifier(GeneratedVisitor)
9429 }
9430 }
9431 struct GeneratedVisitor;
9432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9433 type Value = StopMutation;
9434
9435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9436 formatter.write_str("struct stream_plan.StopMutation")
9437 }
9438
9439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
9440 where
9441 V: serde::de::MapAccess<'de>,
9442 {
9443 let mut actors__ = None;
9444 while let Some(k) = map_.next_key()? {
9445 match k {
9446 GeneratedField::Actors => {
9447 if actors__.is_some() {
9448 return Err(serde::de::Error::duplicate_field("actors"));
9449 }
9450 actors__ =
9451 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9452 .into_iter().map(|x| x.0).collect())
9453 ;
9454 }
9455 }
9456 }
9457 Ok(StopMutation {
9458 actors: actors__.unwrap_or_default(),
9459 })
9460 }
9461 }
9462 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
9463 }
9464}
9465impl serde::Serialize for StreamActor {
9466 #[allow(deprecated)]
9467 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9468 where
9469 S: serde::Serializer,
9470 {
9471 use serde::ser::SerializeStruct;
9472 let mut len = 0;
9473 if self.actor_id != 0 {
9474 len += 1;
9475 }
9476 if self.fragment_id != 0 {
9477 len += 1;
9478 }
9479 if !self.dispatcher.is_empty() {
9480 len += 1;
9481 }
9482 if self.vnode_bitmap.is_some() {
9483 len += 1;
9484 }
9485 if !self.mview_definition.is_empty() {
9486 len += 1;
9487 }
9488 if self.expr_context.is_some() {
9489 len += 1;
9490 }
9491 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
9492 if self.actor_id != 0 {
9493 struct_ser.serialize_field("actorId", &self.actor_id)?;
9494 }
9495 if self.fragment_id != 0 {
9496 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9497 }
9498 if !self.dispatcher.is_empty() {
9499 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
9500 }
9501 if let Some(v) = self.vnode_bitmap.as_ref() {
9502 struct_ser.serialize_field("vnodeBitmap", v)?;
9503 }
9504 if !self.mview_definition.is_empty() {
9505 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
9506 }
9507 if let Some(v) = self.expr_context.as_ref() {
9508 struct_ser.serialize_field("exprContext", v)?;
9509 }
9510 struct_ser.end()
9511 }
9512}
9513impl<'de> serde::Deserialize<'de> for StreamActor {
9514 #[allow(deprecated)]
9515 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9516 where
9517 D: serde::Deserializer<'de>,
9518 {
9519 const FIELDS: &[&str] = &[
9520 "actor_id",
9521 "actorId",
9522 "fragment_id",
9523 "fragmentId",
9524 "dispatcher",
9525 "vnode_bitmap",
9526 "vnodeBitmap",
9527 "mview_definition",
9528 "mviewDefinition",
9529 "expr_context",
9530 "exprContext",
9531 ];
9532
9533 #[allow(clippy::enum_variant_names)]
9534 enum GeneratedField {
9535 ActorId,
9536 FragmentId,
9537 Dispatcher,
9538 VnodeBitmap,
9539 MviewDefinition,
9540 ExprContext,
9541 }
9542 impl<'de> serde::Deserialize<'de> for GeneratedField {
9543 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9544 where
9545 D: serde::Deserializer<'de>,
9546 {
9547 struct GeneratedVisitor;
9548
9549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9550 type Value = GeneratedField;
9551
9552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9553 write!(formatter, "expected one of: {:?}", &FIELDS)
9554 }
9555
9556 #[allow(unused_variables)]
9557 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9558 where
9559 E: serde::de::Error,
9560 {
9561 match value {
9562 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9563 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9564 "dispatcher" => Ok(GeneratedField::Dispatcher),
9565 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
9566 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
9567 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
9568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9569 }
9570 }
9571 }
9572 deserializer.deserialize_identifier(GeneratedVisitor)
9573 }
9574 }
9575 struct GeneratedVisitor;
9576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9577 type Value = StreamActor;
9578
9579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9580 formatter.write_str("struct stream_plan.StreamActor")
9581 }
9582
9583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
9584 where
9585 V: serde::de::MapAccess<'de>,
9586 {
9587 let mut actor_id__ = None;
9588 let mut fragment_id__ = None;
9589 let mut dispatcher__ = None;
9590 let mut vnode_bitmap__ = None;
9591 let mut mview_definition__ = None;
9592 let mut expr_context__ = None;
9593 while let Some(k) = map_.next_key()? {
9594 match k {
9595 GeneratedField::ActorId => {
9596 if actor_id__.is_some() {
9597 return Err(serde::de::Error::duplicate_field("actorId"));
9598 }
9599 actor_id__ =
9600 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9601 ;
9602 }
9603 GeneratedField::FragmentId => {
9604 if fragment_id__.is_some() {
9605 return Err(serde::de::Error::duplicate_field("fragmentId"));
9606 }
9607 fragment_id__ =
9608 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9609 ;
9610 }
9611 GeneratedField::Dispatcher => {
9612 if dispatcher__.is_some() {
9613 return Err(serde::de::Error::duplicate_field("dispatcher"));
9614 }
9615 dispatcher__ = Some(map_.next_value()?);
9616 }
9617 GeneratedField::VnodeBitmap => {
9618 if vnode_bitmap__.is_some() {
9619 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
9620 }
9621 vnode_bitmap__ = map_.next_value()?;
9622 }
9623 GeneratedField::MviewDefinition => {
9624 if mview_definition__.is_some() {
9625 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
9626 }
9627 mview_definition__ = Some(map_.next_value()?);
9628 }
9629 GeneratedField::ExprContext => {
9630 if expr_context__.is_some() {
9631 return Err(serde::de::Error::duplicate_field("exprContext"));
9632 }
9633 expr_context__ = map_.next_value()?;
9634 }
9635 }
9636 }
9637 Ok(StreamActor {
9638 actor_id: actor_id__.unwrap_or_default(),
9639 fragment_id: fragment_id__.unwrap_or_default(),
9640 dispatcher: dispatcher__.unwrap_or_default(),
9641 vnode_bitmap: vnode_bitmap__,
9642 mview_definition: mview_definition__.unwrap_or_default(),
9643 expr_context: expr_context__,
9644 })
9645 }
9646 }
9647 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
9648 }
9649}
9650impl serde::Serialize for StreamCdcScanNode {
9651 #[allow(deprecated)]
9652 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9653 where
9654 S: serde::Serializer,
9655 {
9656 use serde::ser::SerializeStruct;
9657 let mut len = 0;
9658 if self.table_id != 0 {
9659 len += 1;
9660 }
9661 if !self.upstream_column_ids.is_empty() {
9662 len += 1;
9663 }
9664 if !self.output_indices.is_empty() {
9665 len += 1;
9666 }
9667 if self.state_table.is_some() {
9668 len += 1;
9669 }
9670 if self.cdc_table_desc.is_some() {
9671 len += 1;
9672 }
9673 if self.rate_limit.is_some() {
9674 len += 1;
9675 }
9676 if self.disable_backfill {
9677 len += 1;
9678 }
9679 if self.options.is_some() {
9680 len += 1;
9681 }
9682 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
9683 if self.table_id != 0 {
9684 struct_ser.serialize_field("tableId", &self.table_id)?;
9685 }
9686 if !self.upstream_column_ids.is_empty() {
9687 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
9688 }
9689 if !self.output_indices.is_empty() {
9690 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
9691 }
9692 if let Some(v) = self.state_table.as_ref() {
9693 struct_ser.serialize_field("stateTable", v)?;
9694 }
9695 if let Some(v) = self.cdc_table_desc.as_ref() {
9696 struct_ser.serialize_field("cdcTableDesc", v)?;
9697 }
9698 if let Some(v) = self.rate_limit.as_ref() {
9699 struct_ser.serialize_field("rateLimit", v)?;
9700 }
9701 if self.disable_backfill {
9702 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
9703 }
9704 if let Some(v) = self.options.as_ref() {
9705 struct_ser.serialize_field("options", v)?;
9706 }
9707 struct_ser.end()
9708 }
9709}
9710impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
9711 #[allow(deprecated)]
9712 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9713 where
9714 D: serde::Deserializer<'de>,
9715 {
9716 const FIELDS: &[&str] = &[
9717 "table_id",
9718 "tableId",
9719 "upstream_column_ids",
9720 "upstreamColumnIds",
9721 "output_indices",
9722 "outputIndices",
9723 "state_table",
9724 "stateTable",
9725 "cdc_table_desc",
9726 "cdcTableDesc",
9727 "rate_limit",
9728 "rateLimit",
9729 "disable_backfill",
9730 "disableBackfill",
9731 "options",
9732 ];
9733
9734 #[allow(clippy::enum_variant_names)]
9735 enum GeneratedField {
9736 TableId,
9737 UpstreamColumnIds,
9738 OutputIndices,
9739 StateTable,
9740 CdcTableDesc,
9741 RateLimit,
9742 DisableBackfill,
9743 Options,
9744 }
9745 impl<'de> serde::Deserialize<'de> for GeneratedField {
9746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9747 where
9748 D: serde::Deserializer<'de>,
9749 {
9750 struct GeneratedVisitor;
9751
9752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9753 type Value = GeneratedField;
9754
9755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9756 write!(formatter, "expected one of: {:?}", &FIELDS)
9757 }
9758
9759 #[allow(unused_variables)]
9760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9761 where
9762 E: serde::de::Error,
9763 {
9764 match value {
9765 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9766 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
9767 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
9768 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9769 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
9770 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9771 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
9772 "options" => Ok(GeneratedField::Options),
9773 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9774 }
9775 }
9776 }
9777 deserializer.deserialize_identifier(GeneratedVisitor)
9778 }
9779 }
9780 struct GeneratedVisitor;
9781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9782 type Value = StreamCdcScanNode;
9783
9784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9785 formatter.write_str("struct stream_plan.StreamCdcScanNode")
9786 }
9787
9788 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
9789 where
9790 V: serde::de::MapAccess<'de>,
9791 {
9792 let mut table_id__ = None;
9793 let mut upstream_column_ids__ = None;
9794 let mut output_indices__ = None;
9795 let mut state_table__ = None;
9796 let mut cdc_table_desc__ = None;
9797 let mut rate_limit__ = None;
9798 let mut disable_backfill__ = None;
9799 let mut options__ = None;
9800 while let Some(k) = map_.next_key()? {
9801 match k {
9802 GeneratedField::TableId => {
9803 if table_id__.is_some() {
9804 return Err(serde::de::Error::duplicate_field("tableId"));
9805 }
9806 table_id__ =
9807 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9808 ;
9809 }
9810 GeneratedField::UpstreamColumnIds => {
9811 if upstream_column_ids__.is_some() {
9812 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
9813 }
9814 upstream_column_ids__ =
9815 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9816 .into_iter().map(|x| x.0).collect())
9817 ;
9818 }
9819 GeneratedField::OutputIndices => {
9820 if output_indices__.is_some() {
9821 return Err(serde::de::Error::duplicate_field("outputIndices"));
9822 }
9823 output_indices__ =
9824 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9825 .into_iter().map(|x| x.0).collect())
9826 ;
9827 }
9828 GeneratedField::StateTable => {
9829 if state_table__.is_some() {
9830 return Err(serde::de::Error::duplicate_field("stateTable"));
9831 }
9832 state_table__ = map_.next_value()?;
9833 }
9834 GeneratedField::CdcTableDesc => {
9835 if cdc_table_desc__.is_some() {
9836 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
9837 }
9838 cdc_table_desc__ = map_.next_value()?;
9839 }
9840 GeneratedField::RateLimit => {
9841 if rate_limit__.is_some() {
9842 return Err(serde::de::Error::duplicate_field("rateLimit"));
9843 }
9844 rate_limit__ =
9845 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9846 ;
9847 }
9848 GeneratedField::DisableBackfill => {
9849 if disable_backfill__.is_some() {
9850 return Err(serde::de::Error::duplicate_field("disableBackfill"));
9851 }
9852 disable_backfill__ = Some(map_.next_value()?);
9853 }
9854 GeneratedField::Options => {
9855 if options__.is_some() {
9856 return Err(serde::de::Error::duplicate_field("options"));
9857 }
9858 options__ = map_.next_value()?;
9859 }
9860 }
9861 }
9862 Ok(StreamCdcScanNode {
9863 table_id: table_id__.unwrap_or_default(),
9864 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
9865 output_indices: output_indices__.unwrap_or_default(),
9866 state_table: state_table__,
9867 cdc_table_desc: cdc_table_desc__,
9868 rate_limit: rate_limit__,
9869 disable_backfill: disable_backfill__.unwrap_or_default(),
9870 options: options__,
9871 })
9872 }
9873 }
9874 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
9875 }
9876}
9877impl serde::Serialize for StreamCdcScanOptions {
9878 #[allow(deprecated)]
9879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9880 where
9881 S: serde::Serializer,
9882 {
9883 use serde::ser::SerializeStruct;
9884 let mut len = 0;
9885 if self.disable_backfill {
9886 len += 1;
9887 }
9888 if self.snapshot_barrier_interval != 0 {
9889 len += 1;
9890 }
9891 if self.snapshot_batch_size != 0 {
9892 len += 1;
9893 }
9894 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
9895 if self.disable_backfill {
9896 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
9897 }
9898 if self.snapshot_barrier_interval != 0 {
9899 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
9900 }
9901 if self.snapshot_batch_size != 0 {
9902 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
9903 }
9904 struct_ser.end()
9905 }
9906}
9907impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
9908 #[allow(deprecated)]
9909 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9910 where
9911 D: serde::Deserializer<'de>,
9912 {
9913 const FIELDS: &[&str] = &[
9914 "disable_backfill",
9915 "disableBackfill",
9916 "snapshot_barrier_interval",
9917 "snapshotBarrierInterval",
9918 "snapshot_batch_size",
9919 "snapshotBatchSize",
9920 ];
9921
9922 #[allow(clippy::enum_variant_names)]
9923 enum GeneratedField {
9924 DisableBackfill,
9925 SnapshotBarrierInterval,
9926 SnapshotBatchSize,
9927 }
9928 impl<'de> serde::Deserialize<'de> for GeneratedField {
9929 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9930 where
9931 D: serde::Deserializer<'de>,
9932 {
9933 struct GeneratedVisitor;
9934
9935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9936 type Value = GeneratedField;
9937
9938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9939 write!(formatter, "expected one of: {:?}", &FIELDS)
9940 }
9941
9942 #[allow(unused_variables)]
9943 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9944 where
9945 E: serde::de::Error,
9946 {
9947 match value {
9948 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
9949 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
9950 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
9951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9952 }
9953 }
9954 }
9955 deserializer.deserialize_identifier(GeneratedVisitor)
9956 }
9957 }
9958 struct GeneratedVisitor;
9959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9960 type Value = StreamCdcScanOptions;
9961
9962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9963 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
9964 }
9965
9966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
9967 where
9968 V: serde::de::MapAccess<'de>,
9969 {
9970 let mut disable_backfill__ = None;
9971 let mut snapshot_barrier_interval__ = None;
9972 let mut snapshot_batch_size__ = None;
9973 while let Some(k) = map_.next_key()? {
9974 match k {
9975 GeneratedField::DisableBackfill => {
9976 if disable_backfill__.is_some() {
9977 return Err(serde::de::Error::duplicate_field("disableBackfill"));
9978 }
9979 disable_backfill__ = Some(map_.next_value()?);
9980 }
9981 GeneratedField::SnapshotBarrierInterval => {
9982 if snapshot_barrier_interval__.is_some() {
9983 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
9984 }
9985 snapshot_barrier_interval__ =
9986 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9987 ;
9988 }
9989 GeneratedField::SnapshotBatchSize => {
9990 if snapshot_batch_size__.is_some() {
9991 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
9992 }
9993 snapshot_batch_size__ =
9994 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9995 ;
9996 }
9997 }
9998 }
9999 Ok(StreamCdcScanOptions {
10000 disable_backfill: disable_backfill__.unwrap_or_default(),
10001 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10002 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10003 })
10004 }
10005 }
10006 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10007 }
10008}
10009impl serde::Serialize for StreamContext {
10010 #[allow(deprecated)]
10011 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10012 where
10013 S: serde::Serializer,
10014 {
10015 use serde::ser::SerializeStruct;
10016 let mut len = 0;
10017 if !self.timezone.is_empty() {
10018 len += 1;
10019 }
10020 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10021 if !self.timezone.is_empty() {
10022 struct_ser.serialize_field("timezone", &self.timezone)?;
10023 }
10024 struct_ser.end()
10025 }
10026}
10027impl<'de> serde::Deserialize<'de> for StreamContext {
10028 #[allow(deprecated)]
10029 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10030 where
10031 D: serde::Deserializer<'de>,
10032 {
10033 const FIELDS: &[&str] = &[
10034 "timezone",
10035 ];
10036
10037 #[allow(clippy::enum_variant_names)]
10038 enum GeneratedField {
10039 Timezone,
10040 }
10041 impl<'de> serde::Deserialize<'de> for GeneratedField {
10042 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10043 where
10044 D: serde::Deserializer<'de>,
10045 {
10046 struct GeneratedVisitor;
10047
10048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10049 type Value = GeneratedField;
10050
10051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10052 write!(formatter, "expected one of: {:?}", &FIELDS)
10053 }
10054
10055 #[allow(unused_variables)]
10056 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10057 where
10058 E: serde::de::Error,
10059 {
10060 match value {
10061 "timezone" => Ok(GeneratedField::Timezone),
10062 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10063 }
10064 }
10065 }
10066 deserializer.deserialize_identifier(GeneratedVisitor)
10067 }
10068 }
10069 struct GeneratedVisitor;
10070 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10071 type Value = StreamContext;
10072
10073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10074 formatter.write_str("struct stream_plan.StreamContext")
10075 }
10076
10077 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10078 where
10079 V: serde::de::MapAccess<'de>,
10080 {
10081 let mut timezone__ = None;
10082 while let Some(k) = map_.next_key()? {
10083 match k {
10084 GeneratedField::Timezone => {
10085 if timezone__.is_some() {
10086 return Err(serde::de::Error::duplicate_field("timezone"));
10087 }
10088 timezone__ = Some(map_.next_value()?);
10089 }
10090 }
10091 }
10092 Ok(StreamContext {
10093 timezone: timezone__.unwrap_or_default(),
10094 })
10095 }
10096 }
10097 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10098 }
10099}
10100impl serde::Serialize for StreamFragmentGraph {
10101 #[allow(deprecated)]
10102 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10103 where
10104 S: serde::Serializer,
10105 {
10106 use serde::ser::SerializeStruct;
10107 let mut len = 0;
10108 if !self.fragments.is_empty() {
10109 len += 1;
10110 }
10111 if !self.edges.is_empty() {
10112 len += 1;
10113 }
10114 if !self.dependent_table_ids.is_empty() {
10115 len += 1;
10116 }
10117 if self.table_ids_cnt != 0 {
10118 len += 1;
10119 }
10120 if self.ctx.is_some() {
10121 len += 1;
10122 }
10123 if self.parallelism.is_some() {
10124 len += 1;
10125 }
10126 if self.max_parallelism != 0 {
10127 len += 1;
10128 }
10129 if self.backfill_order.is_some() {
10130 len += 1;
10131 }
10132 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10133 if !self.fragments.is_empty() {
10134 struct_ser.serialize_field("fragments", &self.fragments)?;
10135 }
10136 if !self.edges.is_empty() {
10137 struct_ser.serialize_field("edges", &self.edges)?;
10138 }
10139 if !self.dependent_table_ids.is_empty() {
10140 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10141 }
10142 if self.table_ids_cnt != 0 {
10143 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10144 }
10145 if let Some(v) = self.ctx.as_ref() {
10146 struct_ser.serialize_field("ctx", v)?;
10147 }
10148 if let Some(v) = self.parallelism.as_ref() {
10149 struct_ser.serialize_field("parallelism", v)?;
10150 }
10151 if self.max_parallelism != 0 {
10152 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10153 }
10154 if let Some(v) = self.backfill_order.as_ref() {
10155 struct_ser.serialize_field("backfillOrder", v)?;
10156 }
10157 struct_ser.end()
10158 }
10159}
10160impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
10161 #[allow(deprecated)]
10162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10163 where
10164 D: serde::Deserializer<'de>,
10165 {
10166 const FIELDS: &[&str] = &[
10167 "fragments",
10168 "edges",
10169 "dependent_table_ids",
10170 "dependentTableIds",
10171 "table_ids_cnt",
10172 "tableIdsCnt",
10173 "ctx",
10174 "parallelism",
10175 "max_parallelism",
10176 "maxParallelism",
10177 "backfill_order",
10178 "backfillOrder",
10179 ];
10180
10181 #[allow(clippy::enum_variant_names)]
10182 enum GeneratedField {
10183 Fragments,
10184 Edges,
10185 DependentTableIds,
10186 TableIdsCnt,
10187 Ctx,
10188 Parallelism,
10189 MaxParallelism,
10190 BackfillOrder,
10191 }
10192 impl<'de> serde::Deserialize<'de> for GeneratedField {
10193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10194 where
10195 D: serde::Deserializer<'de>,
10196 {
10197 struct GeneratedVisitor;
10198
10199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10200 type Value = GeneratedField;
10201
10202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10203 write!(formatter, "expected one of: {:?}", &FIELDS)
10204 }
10205
10206 #[allow(unused_variables)]
10207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10208 where
10209 E: serde::de::Error,
10210 {
10211 match value {
10212 "fragments" => Ok(GeneratedField::Fragments),
10213 "edges" => Ok(GeneratedField::Edges),
10214 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
10215 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10216 "ctx" => Ok(GeneratedField::Ctx),
10217 "parallelism" => Ok(GeneratedField::Parallelism),
10218 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10219 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
10220 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10221 }
10222 }
10223 }
10224 deserializer.deserialize_identifier(GeneratedVisitor)
10225 }
10226 }
10227 struct GeneratedVisitor;
10228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10229 type Value = StreamFragmentGraph;
10230
10231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10232 formatter.write_str("struct stream_plan.StreamFragmentGraph")
10233 }
10234
10235 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
10236 where
10237 V: serde::de::MapAccess<'de>,
10238 {
10239 let mut fragments__ = None;
10240 let mut edges__ = None;
10241 let mut dependent_table_ids__ = None;
10242 let mut table_ids_cnt__ = None;
10243 let mut ctx__ = None;
10244 let mut parallelism__ = None;
10245 let mut max_parallelism__ = None;
10246 let mut backfill_order__ = None;
10247 while let Some(k) = map_.next_key()? {
10248 match k {
10249 GeneratedField::Fragments => {
10250 if fragments__.is_some() {
10251 return Err(serde::de::Error::duplicate_field("fragments"));
10252 }
10253 fragments__ = Some(
10254 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10255 .into_iter().map(|(k,v)| (k.0, v)).collect()
10256 );
10257 }
10258 GeneratedField::Edges => {
10259 if edges__.is_some() {
10260 return Err(serde::de::Error::duplicate_field("edges"));
10261 }
10262 edges__ = Some(map_.next_value()?);
10263 }
10264 GeneratedField::DependentTableIds => {
10265 if dependent_table_ids__.is_some() {
10266 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
10267 }
10268 dependent_table_ids__ =
10269 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10270 .into_iter().map(|x| x.0).collect())
10271 ;
10272 }
10273 GeneratedField::TableIdsCnt => {
10274 if table_ids_cnt__.is_some() {
10275 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10276 }
10277 table_ids_cnt__ =
10278 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10279 ;
10280 }
10281 GeneratedField::Ctx => {
10282 if ctx__.is_some() {
10283 return Err(serde::de::Error::duplicate_field("ctx"));
10284 }
10285 ctx__ = map_.next_value()?;
10286 }
10287 GeneratedField::Parallelism => {
10288 if parallelism__.is_some() {
10289 return Err(serde::de::Error::duplicate_field("parallelism"));
10290 }
10291 parallelism__ = map_.next_value()?;
10292 }
10293 GeneratedField::MaxParallelism => {
10294 if max_parallelism__.is_some() {
10295 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10296 }
10297 max_parallelism__ =
10298 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10299 ;
10300 }
10301 GeneratedField::BackfillOrder => {
10302 if backfill_order__.is_some() {
10303 return Err(serde::de::Error::duplicate_field("backfillOrder"));
10304 }
10305 backfill_order__ = map_.next_value()?;
10306 }
10307 }
10308 }
10309 Ok(StreamFragmentGraph {
10310 fragments: fragments__.unwrap_or_default(),
10311 edges: edges__.unwrap_or_default(),
10312 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
10313 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10314 ctx: ctx__,
10315 parallelism: parallelism__,
10316 max_parallelism: max_parallelism__.unwrap_or_default(),
10317 backfill_order: backfill_order__,
10318 })
10319 }
10320 }
10321 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
10322 }
10323}
10324impl serde::Serialize for stream_fragment_graph::Parallelism {
10325 #[allow(deprecated)]
10326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10327 where
10328 S: serde::Serializer,
10329 {
10330 use serde::ser::SerializeStruct;
10331 let mut len = 0;
10332 if self.parallelism != 0 {
10333 len += 1;
10334 }
10335 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
10336 if self.parallelism != 0 {
10337 #[allow(clippy::needless_borrow)]
10338 #[allow(clippy::needless_borrows_for_generic_args)]
10339 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
10340 }
10341 struct_ser.end()
10342 }
10343}
10344impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
10345 #[allow(deprecated)]
10346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10347 where
10348 D: serde::Deserializer<'de>,
10349 {
10350 const FIELDS: &[&str] = &[
10351 "parallelism",
10352 ];
10353
10354 #[allow(clippy::enum_variant_names)]
10355 enum GeneratedField {
10356 Parallelism,
10357 }
10358 impl<'de> serde::Deserialize<'de> for GeneratedField {
10359 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10360 where
10361 D: serde::Deserializer<'de>,
10362 {
10363 struct GeneratedVisitor;
10364
10365 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10366 type Value = GeneratedField;
10367
10368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10369 write!(formatter, "expected one of: {:?}", &FIELDS)
10370 }
10371
10372 #[allow(unused_variables)]
10373 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10374 where
10375 E: serde::de::Error,
10376 {
10377 match value {
10378 "parallelism" => Ok(GeneratedField::Parallelism),
10379 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10380 }
10381 }
10382 }
10383 deserializer.deserialize_identifier(GeneratedVisitor)
10384 }
10385 }
10386 struct GeneratedVisitor;
10387 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10388 type Value = stream_fragment_graph::Parallelism;
10389
10390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10391 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
10392 }
10393
10394 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
10395 where
10396 V: serde::de::MapAccess<'de>,
10397 {
10398 let mut parallelism__ = None;
10399 while let Some(k) = map_.next_key()? {
10400 match k {
10401 GeneratedField::Parallelism => {
10402 if parallelism__.is_some() {
10403 return Err(serde::de::Error::duplicate_field("parallelism"));
10404 }
10405 parallelism__ =
10406 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10407 ;
10408 }
10409 }
10410 }
10411 Ok(stream_fragment_graph::Parallelism {
10412 parallelism: parallelism__.unwrap_or_default(),
10413 })
10414 }
10415 }
10416 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
10417 }
10418}
10419impl serde::Serialize for stream_fragment_graph::StreamFragment {
10420 #[allow(deprecated)]
10421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10422 where
10423 S: serde::Serializer,
10424 {
10425 use serde::ser::SerializeStruct;
10426 let mut len = 0;
10427 if self.fragment_id != 0 {
10428 len += 1;
10429 }
10430 if self.node.is_some() {
10431 len += 1;
10432 }
10433 if self.fragment_type_mask != 0 {
10434 len += 1;
10435 }
10436 if self.requires_singleton {
10437 len += 1;
10438 }
10439 if self.table_ids_cnt != 0 {
10440 len += 1;
10441 }
10442 if !self.upstream_table_ids.is_empty() {
10443 len += 1;
10444 }
10445 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
10446 if self.fragment_id != 0 {
10447 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10448 }
10449 if let Some(v) = self.node.as_ref() {
10450 struct_ser.serialize_field("node", v)?;
10451 }
10452 if self.fragment_type_mask != 0 {
10453 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10454 }
10455 if self.requires_singleton {
10456 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
10457 }
10458 if self.table_ids_cnt != 0 {
10459 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10460 }
10461 if !self.upstream_table_ids.is_empty() {
10462 struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
10463 }
10464 struct_ser.end()
10465 }
10466}
10467impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
10468 #[allow(deprecated)]
10469 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10470 where
10471 D: serde::Deserializer<'de>,
10472 {
10473 const FIELDS: &[&str] = &[
10474 "fragment_id",
10475 "fragmentId",
10476 "node",
10477 "fragment_type_mask",
10478 "fragmentTypeMask",
10479 "requires_singleton",
10480 "requiresSingleton",
10481 "table_ids_cnt",
10482 "tableIdsCnt",
10483 "upstream_table_ids",
10484 "upstreamTableIds",
10485 ];
10486
10487 #[allow(clippy::enum_variant_names)]
10488 enum GeneratedField {
10489 FragmentId,
10490 Node,
10491 FragmentTypeMask,
10492 RequiresSingleton,
10493 TableIdsCnt,
10494 UpstreamTableIds,
10495 }
10496 impl<'de> serde::Deserialize<'de> for GeneratedField {
10497 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10498 where
10499 D: serde::Deserializer<'de>,
10500 {
10501 struct GeneratedVisitor;
10502
10503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10504 type Value = GeneratedField;
10505
10506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10507 write!(formatter, "expected one of: {:?}", &FIELDS)
10508 }
10509
10510 #[allow(unused_variables)]
10511 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10512 where
10513 E: serde::de::Error,
10514 {
10515 match value {
10516 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10517 "node" => Ok(GeneratedField::Node),
10518 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10519 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
10520 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10521 "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
10522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10523 }
10524 }
10525 }
10526 deserializer.deserialize_identifier(GeneratedVisitor)
10527 }
10528 }
10529 struct GeneratedVisitor;
10530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10531 type Value = stream_fragment_graph::StreamFragment;
10532
10533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10534 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
10535 }
10536
10537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
10538 where
10539 V: serde::de::MapAccess<'de>,
10540 {
10541 let mut fragment_id__ = None;
10542 let mut node__ = None;
10543 let mut fragment_type_mask__ = None;
10544 let mut requires_singleton__ = None;
10545 let mut table_ids_cnt__ = None;
10546 let mut upstream_table_ids__ = None;
10547 while let Some(k) = map_.next_key()? {
10548 match k {
10549 GeneratedField::FragmentId => {
10550 if fragment_id__.is_some() {
10551 return Err(serde::de::Error::duplicate_field("fragmentId"));
10552 }
10553 fragment_id__ =
10554 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10555 ;
10556 }
10557 GeneratedField::Node => {
10558 if node__.is_some() {
10559 return Err(serde::de::Error::duplicate_field("node"));
10560 }
10561 node__ = map_.next_value()?;
10562 }
10563 GeneratedField::FragmentTypeMask => {
10564 if fragment_type_mask__.is_some() {
10565 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10566 }
10567 fragment_type_mask__ =
10568 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10569 ;
10570 }
10571 GeneratedField::RequiresSingleton => {
10572 if requires_singleton__.is_some() {
10573 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
10574 }
10575 requires_singleton__ = Some(map_.next_value()?);
10576 }
10577 GeneratedField::TableIdsCnt => {
10578 if table_ids_cnt__.is_some() {
10579 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10580 }
10581 table_ids_cnt__ =
10582 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10583 ;
10584 }
10585 GeneratedField::UpstreamTableIds => {
10586 if upstream_table_ids__.is_some() {
10587 return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
10588 }
10589 upstream_table_ids__ =
10590 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10591 .into_iter().map(|x| x.0).collect())
10592 ;
10593 }
10594 }
10595 }
10596 Ok(stream_fragment_graph::StreamFragment {
10597 fragment_id: fragment_id__.unwrap_or_default(),
10598 node: node__,
10599 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10600 requires_singleton: requires_singleton__.unwrap_or_default(),
10601 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10602 upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
10603 })
10604 }
10605 }
10606 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
10607 }
10608}
10609impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
10610 #[allow(deprecated)]
10611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10612 where
10613 S: serde::Serializer,
10614 {
10615 use serde::ser::SerializeStruct;
10616 let mut len = 0;
10617 if self.dispatch_strategy.is_some() {
10618 len += 1;
10619 }
10620 if self.link_id != 0 {
10621 len += 1;
10622 }
10623 if self.upstream_id != 0 {
10624 len += 1;
10625 }
10626 if self.downstream_id != 0 {
10627 len += 1;
10628 }
10629 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
10630 if let Some(v) = self.dispatch_strategy.as_ref() {
10631 struct_ser.serialize_field("dispatchStrategy", v)?;
10632 }
10633 if self.link_id != 0 {
10634 #[allow(clippy::needless_borrow)]
10635 #[allow(clippy::needless_borrows_for_generic_args)]
10636 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
10637 }
10638 if self.upstream_id != 0 {
10639 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
10640 }
10641 if self.downstream_id != 0 {
10642 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
10643 }
10644 struct_ser.end()
10645 }
10646}
10647impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
10648 #[allow(deprecated)]
10649 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10650 where
10651 D: serde::Deserializer<'de>,
10652 {
10653 const FIELDS: &[&str] = &[
10654 "dispatch_strategy",
10655 "dispatchStrategy",
10656 "link_id",
10657 "linkId",
10658 "upstream_id",
10659 "upstreamId",
10660 "downstream_id",
10661 "downstreamId",
10662 ];
10663
10664 #[allow(clippy::enum_variant_names)]
10665 enum GeneratedField {
10666 DispatchStrategy,
10667 LinkId,
10668 UpstreamId,
10669 DownstreamId,
10670 }
10671 impl<'de> serde::Deserialize<'de> for GeneratedField {
10672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10673 where
10674 D: serde::Deserializer<'de>,
10675 {
10676 struct GeneratedVisitor;
10677
10678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10679 type Value = GeneratedField;
10680
10681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10682 write!(formatter, "expected one of: {:?}", &FIELDS)
10683 }
10684
10685 #[allow(unused_variables)]
10686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10687 where
10688 E: serde::de::Error,
10689 {
10690 match value {
10691 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
10692 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
10693 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
10694 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
10695 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10696 }
10697 }
10698 }
10699 deserializer.deserialize_identifier(GeneratedVisitor)
10700 }
10701 }
10702 struct GeneratedVisitor;
10703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10704 type Value = stream_fragment_graph::StreamFragmentEdge;
10705
10706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10707 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
10708 }
10709
10710 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
10711 where
10712 V: serde::de::MapAccess<'de>,
10713 {
10714 let mut dispatch_strategy__ = None;
10715 let mut link_id__ = None;
10716 let mut upstream_id__ = None;
10717 let mut downstream_id__ = None;
10718 while let Some(k) = map_.next_key()? {
10719 match k {
10720 GeneratedField::DispatchStrategy => {
10721 if dispatch_strategy__.is_some() {
10722 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
10723 }
10724 dispatch_strategy__ = map_.next_value()?;
10725 }
10726 GeneratedField::LinkId => {
10727 if link_id__.is_some() {
10728 return Err(serde::de::Error::duplicate_field("linkId"));
10729 }
10730 link_id__ =
10731 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10732 ;
10733 }
10734 GeneratedField::UpstreamId => {
10735 if upstream_id__.is_some() {
10736 return Err(serde::de::Error::duplicate_field("upstreamId"));
10737 }
10738 upstream_id__ =
10739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10740 ;
10741 }
10742 GeneratedField::DownstreamId => {
10743 if downstream_id__.is_some() {
10744 return Err(serde::de::Error::duplicate_field("downstreamId"));
10745 }
10746 downstream_id__ =
10747 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10748 ;
10749 }
10750 }
10751 }
10752 Ok(stream_fragment_graph::StreamFragmentEdge {
10753 dispatch_strategy: dispatch_strategy__,
10754 link_id: link_id__.unwrap_or_default(),
10755 upstream_id: upstream_id__.unwrap_or_default(),
10756 downstream_id: downstream_id__.unwrap_or_default(),
10757 })
10758 }
10759 }
10760 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
10761 }
10762}
10763impl serde::Serialize for StreamFsFetch {
10764 #[allow(deprecated)]
10765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10766 where
10767 S: serde::Serializer,
10768 {
10769 use serde::ser::SerializeStruct;
10770 let mut len = 0;
10771 if self.source_id != 0 {
10772 len += 1;
10773 }
10774 if self.state_table.is_some() {
10775 len += 1;
10776 }
10777 if self.row_id_index.is_some() {
10778 len += 1;
10779 }
10780 if !self.columns.is_empty() {
10781 len += 1;
10782 }
10783 if !self.with_properties.is_empty() {
10784 len += 1;
10785 }
10786 if self.info.is_some() {
10787 len += 1;
10788 }
10789 if !self.source_name.is_empty() {
10790 len += 1;
10791 }
10792 if self.rate_limit.is_some() {
10793 len += 1;
10794 }
10795 if !self.secret_refs.is_empty() {
10796 len += 1;
10797 }
10798 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
10799 if self.source_id != 0 {
10800 struct_ser.serialize_field("sourceId", &self.source_id)?;
10801 }
10802 if let Some(v) = self.state_table.as_ref() {
10803 struct_ser.serialize_field("stateTable", v)?;
10804 }
10805 if let Some(v) = self.row_id_index.as_ref() {
10806 struct_ser.serialize_field("rowIdIndex", v)?;
10807 }
10808 if !self.columns.is_empty() {
10809 struct_ser.serialize_field("columns", &self.columns)?;
10810 }
10811 if !self.with_properties.is_empty() {
10812 struct_ser.serialize_field("withProperties", &self.with_properties)?;
10813 }
10814 if let Some(v) = self.info.as_ref() {
10815 struct_ser.serialize_field("info", v)?;
10816 }
10817 if !self.source_name.is_empty() {
10818 struct_ser.serialize_field("sourceName", &self.source_name)?;
10819 }
10820 if let Some(v) = self.rate_limit.as_ref() {
10821 struct_ser.serialize_field("rateLimit", v)?;
10822 }
10823 if !self.secret_refs.is_empty() {
10824 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10825 }
10826 struct_ser.end()
10827 }
10828}
10829impl<'de> serde::Deserialize<'de> for StreamFsFetch {
10830 #[allow(deprecated)]
10831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10832 where
10833 D: serde::Deserializer<'de>,
10834 {
10835 const FIELDS: &[&str] = &[
10836 "source_id",
10837 "sourceId",
10838 "state_table",
10839 "stateTable",
10840 "row_id_index",
10841 "rowIdIndex",
10842 "columns",
10843 "with_properties",
10844 "withProperties",
10845 "info",
10846 "source_name",
10847 "sourceName",
10848 "rate_limit",
10849 "rateLimit",
10850 "secret_refs",
10851 "secretRefs",
10852 ];
10853
10854 #[allow(clippy::enum_variant_names)]
10855 enum GeneratedField {
10856 SourceId,
10857 StateTable,
10858 RowIdIndex,
10859 Columns,
10860 WithProperties,
10861 Info,
10862 SourceName,
10863 RateLimit,
10864 SecretRefs,
10865 }
10866 impl<'de> serde::Deserialize<'de> for GeneratedField {
10867 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10868 where
10869 D: serde::Deserializer<'de>,
10870 {
10871 struct GeneratedVisitor;
10872
10873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10874 type Value = GeneratedField;
10875
10876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10877 write!(formatter, "expected one of: {:?}", &FIELDS)
10878 }
10879
10880 #[allow(unused_variables)]
10881 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10882 where
10883 E: serde::de::Error,
10884 {
10885 match value {
10886 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
10887 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10888 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10889 "columns" => Ok(GeneratedField::Columns),
10890 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
10891 "info" => Ok(GeneratedField::Info),
10892 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
10893 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10894 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10895 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10896 }
10897 }
10898 }
10899 deserializer.deserialize_identifier(GeneratedVisitor)
10900 }
10901 }
10902 struct GeneratedVisitor;
10903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10904 type Value = StreamFsFetch;
10905
10906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10907 formatter.write_str("struct stream_plan.StreamFsFetch")
10908 }
10909
10910 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
10911 where
10912 V: serde::de::MapAccess<'de>,
10913 {
10914 let mut source_id__ = None;
10915 let mut state_table__ = None;
10916 let mut row_id_index__ = None;
10917 let mut columns__ = None;
10918 let mut with_properties__ = None;
10919 let mut info__ = None;
10920 let mut source_name__ = None;
10921 let mut rate_limit__ = None;
10922 let mut secret_refs__ = None;
10923 while let Some(k) = map_.next_key()? {
10924 match k {
10925 GeneratedField::SourceId => {
10926 if source_id__.is_some() {
10927 return Err(serde::de::Error::duplicate_field("sourceId"));
10928 }
10929 source_id__ =
10930 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10931 ;
10932 }
10933 GeneratedField::StateTable => {
10934 if state_table__.is_some() {
10935 return Err(serde::de::Error::duplicate_field("stateTable"));
10936 }
10937 state_table__ = map_.next_value()?;
10938 }
10939 GeneratedField::RowIdIndex => {
10940 if row_id_index__.is_some() {
10941 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
10942 }
10943 row_id_index__ =
10944 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10945 ;
10946 }
10947 GeneratedField::Columns => {
10948 if columns__.is_some() {
10949 return Err(serde::de::Error::duplicate_field("columns"));
10950 }
10951 columns__ = Some(map_.next_value()?);
10952 }
10953 GeneratedField::WithProperties => {
10954 if with_properties__.is_some() {
10955 return Err(serde::de::Error::duplicate_field("withProperties"));
10956 }
10957 with_properties__ = Some(
10958 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10959 );
10960 }
10961 GeneratedField::Info => {
10962 if info__.is_some() {
10963 return Err(serde::de::Error::duplicate_field("info"));
10964 }
10965 info__ = map_.next_value()?;
10966 }
10967 GeneratedField::SourceName => {
10968 if source_name__.is_some() {
10969 return Err(serde::de::Error::duplicate_field("sourceName"));
10970 }
10971 source_name__ = Some(map_.next_value()?);
10972 }
10973 GeneratedField::RateLimit => {
10974 if rate_limit__.is_some() {
10975 return Err(serde::de::Error::duplicate_field("rateLimit"));
10976 }
10977 rate_limit__ =
10978 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10979 ;
10980 }
10981 GeneratedField::SecretRefs => {
10982 if secret_refs__.is_some() {
10983 return Err(serde::de::Error::duplicate_field("secretRefs"));
10984 }
10985 secret_refs__ = Some(
10986 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10987 );
10988 }
10989 }
10990 }
10991 Ok(StreamFsFetch {
10992 source_id: source_id__.unwrap_or_default(),
10993 state_table: state_table__,
10994 row_id_index: row_id_index__,
10995 columns: columns__.unwrap_or_default(),
10996 with_properties: with_properties__.unwrap_or_default(),
10997 info: info__,
10998 source_name: source_name__.unwrap_or_default(),
10999 rate_limit: rate_limit__,
11000 secret_refs: secret_refs__.unwrap_or_default(),
11001 })
11002 }
11003 }
11004 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11005 }
11006}
11007impl serde::Serialize for StreamFsFetchNode {
11008 #[allow(deprecated)]
11009 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11010 where
11011 S: serde::Serializer,
11012 {
11013 use serde::ser::SerializeStruct;
11014 let mut len = 0;
11015 if self.node_inner.is_some() {
11016 len += 1;
11017 }
11018 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11019 if let Some(v) = self.node_inner.as_ref() {
11020 struct_ser.serialize_field("nodeInner", v)?;
11021 }
11022 struct_ser.end()
11023 }
11024}
11025impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11026 #[allow(deprecated)]
11027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11028 where
11029 D: serde::Deserializer<'de>,
11030 {
11031 const FIELDS: &[&str] = &[
11032 "node_inner",
11033 "nodeInner",
11034 ];
11035
11036 #[allow(clippy::enum_variant_names)]
11037 enum GeneratedField {
11038 NodeInner,
11039 }
11040 impl<'de> serde::Deserialize<'de> for GeneratedField {
11041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11042 where
11043 D: serde::Deserializer<'de>,
11044 {
11045 struct GeneratedVisitor;
11046
11047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11048 type Value = GeneratedField;
11049
11050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11051 write!(formatter, "expected one of: {:?}", &FIELDS)
11052 }
11053
11054 #[allow(unused_variables)]
11055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11056 where
11057 E: serde::de::Error,
11058 {
11059 match value {
11060 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11061 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11062 }
11063 }
11064 }
11065 deserializer.deserialize_identifier(GeneratedVisitor)
11066 }
11067 }
11068 struct GeneratedVisitor;
11069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11070 type Value = StreamFsFetchNode;
11071
11072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11073 formatter.write_str("struct stream_plan.StreamFsFetchNode")
11074 }
11075
11076 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11077 where
11078 V: serde::de::MapAccess<'de>,
11079 {
11080 let mut node_inner__ = None;
11081 while let Some(k) = map_.next_key()? {
11082 match k {
11083 GeneratedField::NodeInner => {
11084 if node_inner__.is_some() {
11085 return Err(serde::de::Error::duplicate_field("nodeInner"));
11086 }
11087 node_inner__ = map_.next_value()?;
11088 }
11089 }
11090 }
11091 Ok(StreamFsFetchNode {
11092 node_inner: node_inner__,
11093 })
11094 }
11095 }
11096 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11097 }
11098}
11099impl serde::Serialize for StreamMessage {
11100 #[allow(deprecated)]
11101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11102 where
11103 S: serde::Serializer,
11104 {
11105 use serde::ser::SerializeStruct;
11106 let mut len = 0;
11107 if self.stream_message.is_some() {
11108 len += 1;
11109 }
11110 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11111 if let Some(v) = self.stream_message.as_ref() {
11112 match v {
11113 stream_message::StreamMessage::StreamChunk(v) => {
11114 struct_ser.serialize_field("streamChunk", v)?;
11115 }
11116 stream_message::StreamMessage::Barrier(v) => {
11117 struct_ser.serialize_field("barrier", v)?;
11118 }
11119 stream_message::StreamMessage::Watermark(v) => {
11120 struct_ser.serialize_field("watermark", v)?;
11121 }
11122 }
11123 }
11124 struct_ser.end()
11125 }
11126}
11127impl<'de> serde::Deserialize<'de> for StreamMessage {
11128 #[allow(deprecated)]
11129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11130 where
11131 D: serde::Deserializer<'de>,
11132 {
11133 const FIELDS: &[&str] = &[
11134 "stream_chunk",
11135 "streamChunk",
11136 "barrier",
11137 "watermark",
11138 ];
11139
11140 #[allow(clippy::enum_variant_names)]
11141 enum GeneratedField {
11142 StreamChunk,
11143 Barrier,
11144 Watermark,
11145 }
11146 impl<'de> serde::Deserialize<'de> for GeneratedField {
11147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11148 where
11149 D: serde::Deserializer<'de>,
11150 {
11151 struct GeneratedVisitor;
11152
11153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11154 type Value = GeneratedField;
11155
11156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11157 write!(formatter, "expected one of: {:?}", &FIELDS)
11158 }
11159
11160 #[allow(unused_variables)]
11161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11162 where
11163 E: serde::de::Error,
11164 {
11165 match value {
11166 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11167 "barrier" => Ok(GeneratedField::Barrier),
11168 "watermark" => Ok(GeneratedField::Watermark),
11169 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11170 }
11171 }
11172 }
11173 deserializer.deserialize_identifier(GeneratedVisitor)
11174 }
11175 }
11176 struct GeneratedVisitor;
11177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11178 type Value = StreamMessage;
11179
11180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11181 formatter.write_str("struct stream_plan.StreamMessage")
11182 }
11183
11184 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
11185 where
11186 V: serde::de::MapAccess<'de>,
11187 {
11188 let mut stream_message__ = None;
11189 while let Some(k) = map_.next_key()? {
11190 match k {
11191 GeneratedField::StreamChunk => {
11192 if stream_message__.is_some() {
11193 return Err(serde::de::Error::duplicate_field("streamChunk"));
11194 }
11195 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
11196;
11197 }
11198 GeneratedField::Barrier => {
11199 if stream_message__.is_some() {
11200 return Err(serde::de::Error::duplicate_field("barrier"));
11201 }
11202 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
11203;
11204 }
11205 GeneratedField::Watermark => {
11206 if stream_message__.is_some() {
11207 return Err(serde::de::Error::duplicate_field("watermark"));
11208 }
11209 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
11210;
11211 }
11212 }
11213 }
11214 Ok(StreamMessage {
11215 stream_message: stream_message__,
11216 })
11217 }
11218 }
11219 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
11220 }
11221}
11222impl serde::Serialize for StreamMessageBatch {
11223 #[allow(deprecated)]
11224 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11225 where
11226 S: serde::Serializer,
11227 {
11228 use serde::ser::SerializeStruct;
11229 let mut len = 0;
11230 if self.stream_message_batch.is_some() {
11231 len += 1;
11232 }
11233 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
11234 if let Some(v) = self.stream_message_batch.as_ref() {
11235 match v {
11236 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
11237 struct_ser.serialize_field("streamChunk", v)?;
11238 }
11239 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
11240 struct_ser.serialize_field("barrierBatch", v)?;
11241 }
11242 stream_message_batch::StreamMessageBatch::Watermark(v) => {
11243 struct_ser.serialize_field("watermark", v)?;
11244 }
11245 }
11246 }
11247 struct_ser.end()
11248 }
11249}
11250impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
11251 #[allow(deprecated)]
11252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11253 where
11254 D: serde::Deserializer<'de>,
11255 {
11256 const FIELDS: &[&str] = &[
11257 "stream_chunk",
11258 "streamChunk",
11259 "barrier_batch",
11260 "barrierBatch",
11261 "watermark",
11262 ];
11263
11264 #[allow(clippy::enum_variant_names)]
11265 enum GeneratedField {
11266 StreamChunk,
11267 BarrierBatch,
11268 Watermark,
11269 }
11270 impl<'de> serde::Deserialize<'de> for GeneratedField {
11271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11272 where
11273 D: serde::Deserializer<'de>,
11274 {
11275 struct GeneratedVisitor;
11276
11277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11278 type Value = GeneratedField;
11279
11280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11281 write!(formatter, "expected one of: {:?}", &FIELDS)
11282 }
11283
11284 #[allow(unused_variables)]
11285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11286 where
11287 E: serde::de::Error,
11288 {
11289 match value {
11290 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11291 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
11292 "watermark" => Ok(GeneratedField::Watermark),
11293 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11294 }
11295 }
11296 }
11297 deserializer.deserialize_identifier(GeneratedVisitor)
11298 }
11299 }
11300 struct GeneratedVisitor;
11301 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11302 type Value = StreamMessageBatch;
11303
11304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11305 formatter.write_str("struct stream_plan.StreamMessageBatch")
11306 }
11307
11308 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
11309 where
11310 V: serde::de::MapAccess<'de>,
11311 {
11312 let mut stream_message_batch__ = None;
11313 while let Some(k) = map_.next_key()? {
11314 match k {
11315 GeneratedField::StreamChunk => {
11316 if stream_message_batch__.is_some() {
11317 return Err(serde::de::Error::duplicate_field("streamChunk"));
11318 }
11319 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
11320;
11321 }
11322 GeneratedField::BarrierBatch => {
11323 if stream_message_batch__.is_some() {
11324 return Err(serde::de::Error::duplicate_field("barrierBatch"));
11325 }
11326 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
11327;
11328 }
11329 GeneratedField::Watermark => {
11330 if stream_message_batch__.is_some() {
11331 return Err(serde::de::Error::duplicate_field("watermark"));
11332 }
11333 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
11334;
11335 }
11336 }
11337 }
11338 Ok(StreamMessageBatch {
11339 stream_message_batch: stream_message_batch__,
11340 })
11341 }
11342 }
11343 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
11344 }
11345}
11346impl serde::Serialize for stream_message_batch::BarrierBatch {
11347 #[allow(deprecated)]
11348 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11349 where
11350 S: serde::Serializer,
11351 {
11352 use serde::ser::SerializeStruct;
11353 let mut len = 0;
11354 if !self.barriers.is_empty() {
11355 len += 1;
11356 }
11357 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
11358 if !self.barriers.is_empty() {
11359 struct_ser.serialize_field("barriers", &self.barriers)?;
11360 }
11361 struct_ser.end()
11362 }
11363}
11364impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
11365 #[allow(deprecated)]
11366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11367 where
11368 D: serde::Deserializer<'de>,
11369 {
11370 const FIELDS: &[&str] = &[
11371 "barriers",
11372 ];
11373
11374 #[allow(clippy::enum_variant_names)]
11375 enum GeneratedField {
11376 Barriers,
11377 }
11378 impl<'de> serde::Deserialize<'de> for GeneratedField {
11379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11380 where
11381 D: serde::Deserializer<'de>,
11382 {
11383 struct GeneratedVisitor;
11384
11385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11386 type Value = GeneratedField;
11387
11388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11389 write!(formatter, "expected one of: {:?}", &FIELDS)
11390 }
11391
11392 #[allow(unused_variables)]
11393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11394 where
11395 E: serde::de::Error,
11396 {
11397 match value {
11398 "barriers" => Ok(GeneratedField::Barriers),
11399 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11400 }
11401 }
11402 }
11403 deserializer.deserialize_identifier(GeneratedVisitor)
11404 }
11405 }
11406 struct GeneratedVisitor;
11407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11408 type Value = stream_message_batch::BarrierBatch;
11409
11410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11411 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
11412 }
11413
11414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
11415 where
11416 V: serde::de::MapAccess<'de>,
11417 {
11418 let mut barriers__ = None;
11419 while let Some(k) = map_.next_key()? {
11420 match k {
11421 GeneratedField::Barriers => {
11422 if barriers__.is_some() {
11423 return Err(serde::de::Error::duplicate_field("barriers"));
11424 }
11425 barriers__ = Some(map_.next_value()?);
11426 }
11427 }
11428 }
11429 Ok(stream_message_batch::BarrierBatch {
11430 barriers: barriers__.unwrap_or_default(),
11431 })
11432 }
11433 }
11434 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
11435 }
11436}
11437impl serde::Serialize for StreamNode {
11438 #[allow(deprecated)]
11439 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11440 where
11441 S: serde::Serializer,
11442 {
11443 use serde::ser::SerializeStruct;
11444 let mut len = 0;
11445 if self.operator_id != 0 {
11446 len += 1;
11447 }
11448 if !self.input.is_empty() {
11449 len += 1;
11450 }
11451 if !self.stream_key.is_empty() {
11452 len += 1;
11453 }
11454 if self.append_only {
11455 len += 1;
11456 }
11457 if !self.identity.is_empty() {
11458 len += 1;
11459 }
11460 if !self.fields.is_empty() {
11461 len += 1;
11462 }
11463 if self.node_body.is_some() {
11464 len += 1;
11465 }
11466 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
11467 if self.operator_id != 0 {
11468 #[allow(clippy::needless_borrow)]
11469 #[allow(clippy::needless_borrows_for_generic_args)]
11470 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
11471 }
11472 if !self.input.is_empty() {
11473 struct_ser.serialize_field("input", &self.input)?;
11474 }
11475 if !self.stream_key.is_empty() {
11476 struct_ser.serialize_field("streamKey", &self.stream_key)?;
11477 }
11478 if self.append_only {
11479 struct_ser.serialize_field("appendOnly", &self.append_only)?;
11480 }
11481 if !self.identity.is_empty() {
11482 struct_ser.serialize_field("identity", &self.identity)?;
11483 }
11484 if !self.fields.is_empty() {
11485 struct_ser.serialize_field("fields", &self.fields)?;
11486 }
11487 if let Some(v) = self.node_body.as_ref() {
11488 match v {
11489 stream_node::NodeBody::Source(v) => {
11490 struct_ser.serialize_field("source", v)?;
11491 }
11492 stream_node::NodeBody::Project(v) => {
11493 struct_ser.serialize_field("project", v)?;
11494 }
11495 stream_node::NodeBody::Filter(v) => {
11496 struct_ser.serialize_field("filter", v)?;
11497 }
11498 stream_node::NodeBody::Materialize(v) => {
11499 struct_ser.serialize_field("materialize", v)?;
11500 }
11501 stream_node::NodeBody::StatelessSimpleAgg(v) => {
11502 struct_ser.serialize_field("statelessSimpleAgg", v)?;
11503 }
11504 stream_node::NodeBody::SimpleAgg(v) => {
11505 struct_ser.serialize_field("simpleAgg", v)?;
11506 }
11507 stream_node::NodeBody::HashAgg(v) => {
11508 struct_ser.serialize_field("hashAgg", v)?;
11509 }
11510 stream_node::NodeBody::AppendOnlyTopN(v) => {
11511 struct_ser.serialize_field("appendOnlyTopN", v)?;
11512 }
11513 stream_node::NodeBody::HashJoin(v) => {
11514 struct_ser.serialize_field("hashJoin", v)?;
11515 }
11516 stream_node::NodeBody::TopN(v) => {
11517 struct_ser.serialize_field("topN", v)?;
11518 }
11519 stream_node::NodeBody::HopWindow(v) => {
11520 struct_ser.serialize_field("hopWindow", v)?;
11521 }
11522 stream_node::NodeBody::Merge(v) => {
11523 struct_ser.serialize_field("merge", v)?;
11524 }
11525 stream_node::NodeBody::Exchange(v) => {
11526 struct_ser.serialize_field("exchange", v)?;
11527 }
11528 stream_node::NodeBody::StreamScan(v) => {
11529 struct_ser.serialize_field("streamScan", v)?;
11530 }
11531 stream_node::NodeBody::BatchPlan(v) => {
11532 struct_ser.serialize_field("batchPlan", v)?;
11533 }
11534 stream_node::NodeBody::Lookup(v) => {
11535 struct_ser.serialize_field("lookup", v)?;
11536 }
11537 stream_node::NodeBody::Arrange(v) => {
11538 struct_ser.serialize_field("arrange", v)?;
11539 }
11540 stream_node::NodeBody::LookupUnion(v) => {
11541 struct_ser.serialize_field("lookupUnion", v)?;
11542 }
11543 stream_node::NodeBody::Union(v) => {
11544 struct_ser.serialize_field("union", v)?;
11545 }
11546 stream_node::NodeBody::DeltaIndexJoin(v) => {
11547 struct_ser.serialize_field("deltaIndexJoin", v)?;
11548 }
11549 stream_node::NodeBody::Sink(v) => {
11550 struct_ser.serialize_field("sink", v)?;
11551 }
11552 stream_node::NodeBody::Expand(v) => {
11553 struct_ser.serialize_field("expand", v)?;
11554 }
11555 stream_node::NodeBody::DynamicFilter(v) => {
11556 struct_ser.serialize_field("dynamicFilter", v)?;
11557 }
11558 stream_node::NodeBody::ProjectSet(v) => {
11559 struct_ser.serialize_field("projectSet", v)?;
11560 }
11561 stream_node::NodeBody::GroupTopN(v) => {
11562 struct_ser.serialize_field("groupTopN", v)?;
11563 }
11564 stream_node::NodeBody::Sort(v) => {
11565 struct_ser.serialize_field("sort", v)?;
11566 }
11567 stream_node::NodeBody::WatermarkFilter(v) => {
11568 struct_ser.serialize_field("watermarkFilter", v)?;
11569 }
11570 stream_node::NodeBody::Dml(v) => {
11571 struct_ser.serialize_field("dml", v)?;
11572 }
11573 stream_node::NodeBody::RowIdGen(v) => {
11574 struct_ser.serialize_field("rowIdGen", v)?;
11575 }
11576 stream_node::NodeBody::Now(v) => {
11577 struct_ser.serialize_field("now", v)?;
11578 }
11579 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
11580 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
11581 }
11582 stream_node::NodeBody::TemporalJoin(v) => {
11583 struct_ser.serialize_field("temporalJoin", v)?;
11584 }
11585 stream_node::NodeBody::BarrierRecv(v) => {
11586 struct_ser.serialize_field("barrierRecv", v)?;
11587 }
11588 stream_node::NodeBody::Values(v) => {
11589 struct_ser.serialize_field("values", v)?;
11590 }
11591 stream_node::NodeBody::AppendOnlyDedup(v) => {
11592 struct_ser.serialize_field("appendOnlyDedup", v)?;
11593 }
11594 stream_node::NodeBody::NoOp(v) => {
11595 struct_ser.serialize_field("noOp", v)?;
11596 }
11597 stream_node::NodeBody::EowcOverWindow(v) => {
11598 struct_ser.serialize_field("eowcOverWindow", v)?;
11599 }
11600 stream_node::NodeBody::OverWindow(v) => {
11601 struct_ser.serialize_field("overWindow", v)?;
11602 }
11603 stream_node::NodeBody::StreamFsFetch(v) => {
11604 struct_ser.serialize_field("streamFsFetch", v)?;
11605 }
11606 stream_node::NodeBody::StreamCdcScan(v) => {
11607 struct_ser.serialize_field("streamCdcScan", v)?;
11608 }
11609 stream_node::NodeBody::CdcFilter(v) => {
11610 struct_ser.serialize_field("cdcFilter", v)?;
11611 }
11612 stream_node::NodeBody::SourceBackfill(v) => {
11613 struct_ser.serialize_field("sourceBackfill", v)?;
11614 }
11615 stream_node::NodeBody::Changelog(v) => {
11616 struct_ser.serialize_field("changelog", v)?;
11617 }
11618 stream_node::NodeBody::LocalApproxPercentile(v) => {
11619 struct_ser.serialize_field("localApproxPercentile", v)?;
11620 }
11621 stream_node::NodeBody::GlobalApproxPercentile(v) => {
11622 struct_ser.serialize_field("globalApproxPercentile", v)?;
11623 }
11624 stream_node::NodeBody::RowMerge(v) => {
11625 struct_ser.serialize_field("rowMerge", v)?;
11626 }
11627 stream_node::NodeBody::AsOfJoin(v) => {
11628 struct_ser.serialize_field("asOfJoin", v)?;
11629 }
11630 stream_node::NodeBody::SyncLogStore(v) => {
11631 struct_ser.serialize_field("syncLogStore", v)?;
11632 }
11633 stream_node::NodeBody::MaterializedExprs(v) => {
11634 struct_ser.serialize_field("materializedExprs", v)?;
11635 }
11636 }
11637 }
11638 struct_ser.end()
11639 }
11640}
11641impl<'de> serde::Deserialize<'de> for StreamNode {
11642 #[allow(deprecated)]
11643 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11644 where
11645 D: serde::Deserializer<'de>,
11646 {
11647 const FIELDS: &[&str] = &[
11648 "operator_id",
11649 "operatorId",
11650 "input",
11651 "stream_key",
11652 "streamKey",
11653 "append_only",
11654 "appendOnly",
11655 "identity",
11656 "fields",
11657 "source",
11658 "project",
11659 "filter",
11660 "materialize",
11661 "stateless_simple_agg",
11662 "statelessSimpleAgg",
11663 "simple_agg",
11664 "simpleAgg",
11665 "hash_agg",
11666 "hashAgg",
11667 "append_only_top_n",
11668 "appendOnlyTopN",
11669 "hash_join",
11670 "hashJoin",
11671 "top_n",
11672 "topN",
11673 "hop_window",
11674 "hopWindow",
11675 "merge",
11676 "exchange",
11677 "stream_scan",
11678 "streamScan",
11679 "batch_plan",
11680 "batchPlan",
11681 "lookup",
11682 "arrange",
11683 "lookup_union",
11684 "lookupUnion",
11685 "union",
11686 "delta_index_join",
11687 "deltaIndexJoin",
11688 "sink",
11689 "expand",
11690 "dynamic_filter",
11691 "dynamicFilter",
11692 "project_set",
11693 "projectSet",
11694 "group_top_n",
11695 "groupTopN",
11696 "sort",
11697 "watermark_filter",
11698 "watermarkFilter",
11699 "dml",
11700 "row_id_gen",
11701 "rowIdGen",
11702 "now",
11703 "append_only_group_top_n",
11704 "appendOnlyGroupTopN",
11705 "temporal_join",
11706 "temporalJoin",
11707 "barrier_recv",
11708 "barrierRecv",
11709 "values",
11710 "append_only_dedup",
11711 "appendOnlyDedup",
11712 "no_op",
11713 "noOp",
11714 "eowc_over_window",
11715 "eowcOverWindow",
11716 "over_window",
11717 "overWindow",
11718 "stream_fs_fetch",
11719 "streamFsFetch",
11720 "stream_cdc_scan",
11721 "streamCdcScan",
11722 "cdc_filter",
11723 "cdcFilter",
11724 "source_backfill",
11725 "sourceBackfill",
11726 "changelog",
11727 "local_approx_percentile",
11728 "localApproxPercentile",
11729 "global_approx_percentile",
11730 "globalApproxPercentile",
11731 "row_merge",
11732 "rowMerge",
11733 "as_of_join",
11734 "asOfJoin",
11735 "sync_log_store",
11736 "syncLogStore",
11737 "materialized_exprs",
11738 "materializedExprs",
11739 ];
11740
11741 #[allow(clippy::enum_variant_names)]
11742 enum GeneratedField {
11743 OperatorId,
11744 Input,
11745 StreamKey,
11746 AppendOnly,
11747 Identity,
11748 Fields,
11749 Source,
11750 Project,
11751 Filter,
11752 Materialize,
11753 StatelessSimpleAgg,
11754 SimpleAgg,
11755 HashAgg,
11756 AppendOnlyTopN,
11757 HashJoin,
11758 TopN,
11759 HopWindow,
11760 Merge,
11761 Exchange,
11762 StreamScan,
11763 BatchPlan,
11764 Lookup,
11765 Arrange,
11766 LookupUnion,
11767 Union,
11768 DeltaIndexJoin,
11769 Sink,
11770 Expand,
11771 DynamicFilter,
11772 ProjectSet,
11773 GroupTopN,
11774 Sort,
11775 WatermarkFilter,
11776 Dml,
11777 RowIdGen,
11778 Now,
11779 AppendOnlyGroupTopN,
11780 TemporalJoin,
11781 BarrierRecv,
11782 Values,
11783 AppendOnlyDedup,
11784 NoOp,
11785 EowcOverWindow,
11786 OverWindow,
11787 StreamFsFetch,
11788 StreamCdcScan,
11789 CdcFilter,
11790 SourceBackfill,
11791 Changelog,
11792 LocalApproxPercentile,
11793 GlobalApproxPercentile,
11794 RowMerge,
11795 AsOfJoin,
11796 SyncLogStore,
11797 MaterializedExprs,
11798 }
11799 impl<'de> serde::Deserialize<'de> for GeneratedField {
11800 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11801 where
11802 D: serde::Deserializer<'de>,
11803 {
11804 struct GeneratedVisitor;
11805
11806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11807 type Value = GeneratedField;
11808
11809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11810 write!(formatter, "expected one of: {:?}", &FIELDS)
11811 }
11812
11813 #[allow(unused_variables)]
11814 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11815 where
11816 E: serde::de::Error,
11817 {
11818 match value {
11819 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
11820 "input" => Ok(GeneratedField::Input),
11821 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
11822 "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
11823 "identity" => Ok(GeneratedField::Identity),
11824 "fields" => Ok(GeneratedField::Fields),
11825 "source" => Ok(GeneratedField::Source),
11826 "project" => Ok(GeneratedField::Project),
11827 "filter" => Ok(GeneratedField::Filter),
11828 "materialize" => Ok(GeneratedField::Materialize),
11829 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
11830 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
11831 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
11832 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
11833 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
11834 "topN" | "top_n" => Ok(GeneratedField::TopN),
11835 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
11836 "merge" => Ok(GeneratedField::Merge),
11837 "exchange" => Ok(GeneratedField::Exchange),
11838 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
11839 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
11840 "lookup" => Ok(GeneratedField::Lookup),
11841 "arrange" => Ok(GeneratedField::Arrange),
11842 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
11843 "union" => Ok(GeneratedField::Union),
11844 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
11845 "sink" => Ok(GeneratedField::Sink),
11846 "expand" => Ok(GeneratedField::Expand),
11847 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
11848 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
11849 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
11850 "sort" => Ok(GeneratedField::Sort),
11851 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
11852 "dml" => Ok(GeneratedField::Dml),
11853 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
11854 "now" => Ok(GeneratedField::Now),
11855 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
11856 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
11857 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
11858 "values" => Ok(GeneratedField::Values),
11859 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
11860 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
11861 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
11862 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
11863 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
11864 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
11865 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
11866 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
11867 "changelog" => Ok(GeneratedField::Changelog),
11868 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
11869 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
11870 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
11871 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
11872 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
11873 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
11874 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11875 }
11876 }
11877 }
11878 deserializer.deserialize_identifier(GeneratedVisitor)
11879 }
11880 }
11881 struct GeneratedVisitor;
11882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11883 type Value = StreamNode;
11884
11885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11886 formatter.write_str("struct stream_plan.StreamNode")
11887 }
11888
11889 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
11890 where
11891 V: serde::de::MapAccess<'de>,
11892 {
11893 let mut operator_id__ = None;
11894 let mut input__ = None;
11895 let mut stream_key__ = None;
11896 let mut append_only__ = None;
11897 let mut identity__ = None;
11898 let mut fields__ = None;
11899 let mut node_body__ = None;
11900 while let Some(k) = map_.next_key()? {
11901 match k {
11902 GeneratedField::OperatorId => {
11903 if operator_id__.is_some() {
11904 return Err(serde::de::Error::duplicate_field("operatorId"));
11905 }
11906 operator_id__ =
11907 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11908 ;
11909 }
11910 GeneratedField::Input => {
11911 if input__.is_some() {
11912 return Err(serde::de::Error::duplicate_field("input"));
11913 }
11914 input__ = Some(map_.next_value()?);
11915 }
11916 GeneratedField::StreamKey => {
11917 if stream_key__.is_some() {
11918 return Err(serde::de::Error::duplicate_field("streamKey"));
11919 }
11920 stream_key__ =
11921 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11922 .into_iter().map(|x| x.0).collect())
11923 ;
11924 }
11925 GeneratedField::AppendOnly => {
11926 if append_only__.is_some() {
11927 return Err(serde::de::Error::duplicate_field("appendOnly"));
11928 }
11929 append_only__ = Some(map_.next_value()?);
11930 }
11931 GeneratedField::Identity => {
11932 if identity__.is_some() {
11933 return Err(serde::de::Error::duplicate_field("identity"));
11934 }
11935 identity__ = Some(map_.next_value()?);
11936 }
11937 GeneratedField::Fields => {
11938 if fields__.is_some() {
11939 return Err(serde::de::Error::duplicate_field("fields"));
11940 }
11941 fields__ = Some(map_.next_value()?);
11942 }
11943 GeneratedField::Source => {
11944 if node_body__.is_some() {
11945 return Err(serde::de::Error::duplicate_field("source"));
11946 }
11947 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
11948;
11949 }
11950 GeneratedField::Project => {
11951 if node_body__.is_some() {
11952 return Err(serde::de::Error::duplicate_field("project"));
11953 }
11954 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
11955;
11956 }
11957 GeneratedField::Filter => {
11958 if node_body__.is_some() {
11959 return Err(serde::de::Error::duplicate_field("filter"));
11960 }
11961 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
11962;
11963 }
11964 GeneratedField::Materialize => {
11965 if node_body__.is_some() {
11966 return Err(serde::de::Error::duplicate_field("materialize"));
11967 }
11968 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
11969;
11970 }
11971 GeneratedField::StatelessSimpleAgg => {
11972 if node_body__.is_some() {
11973 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
11974 }
11975 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
11976;
11977 }
11978 GeneratedField::SimpleAgg => {
11979 if node_body__.is_some() {
11980 return Err(serde::de::Error::duplicate_field("simpleAgg"));
11981 }
11982 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
11983;
11984 }
11985 GeneratedField::HashAgg => {
11986 if node_body__.is_some() {
11987 return Err(serde::de::Error::duplicate_field("hashAgg"));
11988 }
11989 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
11990;
11991 }
11992 GeneratedField::AppendOnlyTopN => {
11993 if node_body__.is_some() {
11994 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
11995 }
11996 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
11997;
11998 }
11999 GeneratedField::HashJoin => {
12000 if node_body__.is_some() {
12001 return Err(serde::de::Error::duplicate_field("hashJoin"));
12002 }
12003 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12004;
12005 }
12006 GeneratedField::TopN => {
12007 if node_body__.is_some() {
12008 return Err(serde::de::Error::duplicate_field("topN"));
12009 }
12010 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12011;
12012 }
12013 GeneratedField::HopWindow => {
12014 if node_body__.is_some() {
12015 return Err(serde::de::Error::duplicate_field("hopWindow"));
12016 }
12017 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12018;
12019 }
12020 GeneratedField::Merge => {
12021 if node_body__.is_some() {
12022 return Err(serde::de::Error::duplicate_field("merge"));
12023 }
12024 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12025;
12026 }
12027 GeneratedField::Exchange => {
12028 if node_body__.is_some() {
12029 return Err(serde::de::Error::duplicate_field("exchange"));
12030 }
12031 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12032;
12033 }
12034 GeneratedField::StreamScan => {
12035 if node_body__.is_some() {
12036 return Err(serde::de::Error::duplicate_field("streamScan"));
12037 }
12038 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12039;
12040 }
12041 GeneratedField::BatchPlan => {
12042 if node_body__.is_some() {
12043 return Err(serde::de::Error::duplicate_field("batchPlan"));
12044 }
12045 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12046;
12047 }
12048 GeneratedField::Lookup => {
12049 if node_body__.is_some() {
12050 return Err(serde::de::Error::duplicate_field("lookup"));
12051 }
12052 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12053;
12054 }
12055 GeneratedField::Arrange => {
12056 if node_body__.is_some() {
12057 return Err(serde::de::Error::duplicate_field("arrange"));
12058 }
12059 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12060;
12061 }
12062 GeneratedField::LookupUnion => {
12063 if node_body__.is_some() {
12064 return Err(serde::de::Error::duplicate_field("lookupUnion"));
12065 }
12066 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12067;
12068 }
12069 GeneratedField::Union => {
12070 if node_body__.is_some() {
12071 return Err(serde::de::Error::duplicate_field("union"));
12072 }
12073 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12074;
12075 }
12076 GeneratedField::DeltaIndexJoin => {
12077 if node_body__.is_some() {
12078 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12079 }
12080 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12081;
12082 }
12083 GeneratedField::Sink => {
12084 if node_body__.is_some() {
12085 return Err(serde::de::Error::duplicate_field("sink"));
12086 }
12087 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12088;
12089 }
12090 GeneratedField::Expand => {
12091 if node_body__.is_some() {
12092 return Err(serde::de::Error::duplicate_field("expand"));
12093 }
12094 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12095;
12096 }
12097 GeneratedField::DynamicFilter => {
12098 if node_body__.is_some() {
12099 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12100 }
12101 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12102;
12103 }
12104 GeneratedField::ProjectSet => {
12105 if node_body__.is_some() {
12106 return Err(serde::de::Error::duplicate_field("projectSet"));
12107 }
12108 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12109;
12110 }
12111 GeneratedField::GroupTopN => {
12112 if node_body__.is_some() {
12113 return Err(serde::de::Error::duplicate_field("groupTopN"));
12114 }
12115 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12116;
12117 }
12118 GeneratedField::Sort => {
12119 if node_body__.is_some() {
12120 return Err(serde::de::Error::duplicate_field("sort"));
12121 }
12122 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12123;
12124 }
12125 GeneratedField::WatermarkFilter => {
12126 if node_body__.is_some() {
12127 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12128 }
12129 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12130;
12131 }
12132 GeneratedField::Dml => {
12133 if node_body__.is_some() {
12134 return Err(serde::de::Error::duplicate_field("dml"));
12135 }
12136 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12137;
12138 }
12139 GeneratedField::RowIdGen => {
12140 if node_body__.is_some() {
12141 return Err(serde::de::Error::duplicate_field("rowIdGen"));
12142 }
12143 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12144;
12145 }
12146 GeneratedField::Now => {
12147 if node_body__.is_some() {
12148 return Err(serde::de::Error::duplicate_field("now"));
12149 }
12150 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12151;
12152 }
12153 GeneratedField::AppendOnlyGroupTopN => {
12154 if node_body__.is_some() {
12155 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
12156 }
12157 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
12158;
12159 }
12160 GeneratedField::TemporalJoin => {
12161 if node_body__.is_some() {
12162 return Err(serde::de::Error::duplicate_field("temporalJoin"));
12163 }
12164 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
12165;
12166 }
12167 GeneratedField::BarrierRecv => {
12168 if node_body__.is_some() {
12169 return Err(serde::de::Error::duplicate_field("barrierRecv"));
12170 }
12171 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
12172;
12173 }
12174 GeneratedField::Values => {
12175 if node_body__.is_some() {
12176 return Err(serde::de::Error::duplicate_field("values"));
12177 }
12178 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
12179;
12180 }
12181 GeneratedField::AppendOnlyDedup => {
12182 if node_body__.is_some() {
12183 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
12184 }
12185 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
12186;
12187 }
12188 GeneratedField::NoOp => {
12189 if node_body__.is_some() {
12190 return Err(serde::de::Error::duplicate_field("noOp"));
12191 }
12192 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
12193;
12194 }
12195 GeneratedField::EowcOverWindow => {
12196 if node_body__.is_some() {
12197 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
12198 }
12199 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
12200;
12201 }
12202 GeneratedField::OverWindow => {
12203 if node_body__.is_some() {
12204 return Err(serde::de::Error::duplicate_field("overWindow"));
12205 }
12206 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
12207;
12208 }
12209 GeneratedField::StreamFsFetch => {
12210 if node_body__.is_some() {
12211 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
12212 }
12213 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
12214;
12215 }
12216 GeneratedField::StreamCdcScan => {
12217 if node_body__.is_some() {
12218 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
12219 }
12220 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
12221;
12222 }
12223 GeneratedField::CdcFilter => {
12224 if node_body__.is_some() {
12225 return Err(serde::de::Error::duplicate_field("cdcFilter"));
12226 }
12227 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
12228;
12229 }
12230 GeneratedField::SourceBackfill => {
12231 if node_body__.is_some() {
12232 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
12233 }
12234 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
12235;
12236 }
12237 GeneratedField::Changelog => {
12238 if node_body__.is_some() {
12239 return Err(serde::de::Error::duplicate_field("changelog"));
12240 }
12241 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
12242;
12243 }
12244 GeneratedField::LocalApproxPercentile => {
12245 if node_body__.is_some() {
12246 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
12247 }
12248 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
12249;
12250 }
12251 GeneratedField::GlobalApproxPercentile => {
12252 if node_body__.is_some() {
12253 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
12254 }
12255 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
12256;
12257 }
12258 GeneratedField::RowMerge => {
12259 if node_body__.is_some() {
12260 return Err(serde::de::Error::duplicate_field("rowMerge"));
12261 }
12262 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
12263;
12264 }
12265 GeneratedField::AsOfJoin => {
12266 if node_body__.is_some() {
12267 return Err(serde::de::Error::duplicate_field("asOfJoin"));
12268 }
12269 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
12270;
12271 }
12272 GeneratedField::SyncLogStore => {
12273 if node_body__.is_some() {
12274 return Err(serde::de::Error::duplicate_field("syncLogStore"));
12275 }
12276 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
12277;
12278 }
12279 GeneratedField::MaterializedExprs => {
12280 if node_body__.is_some() {
12281 return Err(serde::de::Error::duplicate_field("materializedExprs"));
12282 }
12283 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
12284;
12285 }
12286 }
12287 }
12288 Ok(StreamNode {
12289 operator_id: operator_id__.unwrap_or_default(),
12290 input: input__.unwrap_or_default(),
12291 stream_key: stream_key__.unwrap_or_default(),
12292 append_only: append_only__.unwrap_or_default(),
12293 identity: identity__.unwrap_or_default(),
12294 fields: fields__.unwrap_or_default(),
12295 node_body: node_body__,
12296 })
12297 }
12298 }
12299 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
12300 }
12301}
12302impl serde::Serialize for StreamScanNode {
12303 #[allow(deprecated)]
12304 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12305 where
12306 S: serde::Serializer,
12307 {
12308 use serde::ser::SerializeStruct;
12309 let mut len = 0;
12310 if self.table_id != 0 {
12311 len += 1;
12312 }
12313 if !self.upstream_column_ids.is_empty() {
12314 len += 1;
12315 }
12316 if !self.output_indices.is_empty() {
12317 len += 1;
12318 }
12319 if self.stream_scan_type != 0 {
12320 len += 1;
12321 }
12322 if self.state_table.is_some() {
12323 len += 1;
12324 }
12325 if self.table_desc.is_some() {
12326 len += 1;
12327 }
12328 if self.rate_limit.is_some() {
12329 len += 1;
12330 }
12331 if self.snapshot_read_barrier_interval != 0 {
12332 len += 1;
12333 }
12334 if self.arrangement_table.is_some() {
12335 len += 1;
12336 }
12337 if self.snapshot_backfill_epoch.is_some() {
12338 len += 1;
12339 }
12340 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
12341 if self.table_id != 0 {
12342 struct_ser.serialize_field("tableId", &self.table_id)?;
12343 }
12344 if !self.upstream_column_ids.is_empty() {
12345 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12346 }
12347 if !self.output_indices.is_empty() {
12348 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12349 }
12350 if self.stream_scan_type != 0 {
12351 let v = StreamScanType::try_from(self.stream_scan_type)
12352 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
12353 struct_ser.serialize_field("streamScanType", &v)?;
12354 }
12355 if let Some(v) = self.state_table.as_ref() {
12356 struct_ser.serialize_field("stateTable", v)?;
12357 }
12358 if let Some(v) = self.table_desc.as_ref() {
12359 struct_ser.serialize_field("tableDesc", v)?;
12360 }
12361 if let Some(v) = self.rate_limit.as_ref() {
12362 struct_ser.serialize_field("rateLimit", v)?;
12363 }
12364 if self.snapshot_read_barrier_interval != 0 {
12365 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
12366 }
12367 if let Some(v) = self.arrangement_table.as_ref() {
12368 struct_ser.serialize_field("arrangementTable", v)?;
12369 }
12370 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
12371 #[allow(clippy::needless_borrow)]
12372 #[allow(clippy::needless_borrows_for_generic_args)]
12373 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
12374 }
12375 struct_ser.end()
12376 }
12377}
12378impl<'de> serde::Deserialize<'de> for StreamScanNode {
12379 #[allow(deprecated)]
12380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12381 where
12382 D: serde::Deserializer<'de>,
12383 {
12384 const FIELDS: &[&str] = &[
12385 "table_id",
12386 "tableId",
12387 "upstream_column_ids",
12388 "upstreamColumnIds",
12389 "output_indices",
12390 "outputIndices",
12391 "stream_scan_type",
12392 "streamScanType",
12393 "state_table",
12394 "stateTable",
12395 "table_desc",
12396 "tableDesc",
12397 "rate_limit",
12398 "rateLimit",
12399 "snapshot_read_barrier_interval",
12400 "snapshotReadBarrierInterval",
12401 "arrangement_table",
12402 "arrangementTable",
12403 "snapshot_backfill_epoch",
12404 "snapshotBackfillEpoch",
12405 ];
12406
12407 #[allow(clippy::enum_variant_names)]
12408 enum GeneratedField {
12409 TableId,
12410 UpstreamColumnIds,
12411 OutputIndices,
12412 StreamScanType,
12413 StateTable,
12414 TableDesc,
12415 RateLimit,
12416 SnapshotReadBarrierInterval,
12417 ArrangementTable,
12418 SnapshotBackfillEpoch,
12419 }
12420 impl<'de> serde::Deserialize<'de> for GeneratedField {
12421 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12422 where
12423 D: serde::Deserializer<'de>,
12424 {
12425 struct GeneratedVisitor;
12426
12427 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12428 type Value = GeneratedField;
12429
12430 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12431 write!(formatter, "expected one of: {:?}", &FIELDS)
12432 }
12433
12434 #[allow(unused_variables)]
12435 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12436 where
12437 E: serde::de::Error,
12438 {
12439 match value {
12440 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12441 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12442 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12443 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
12444 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12445 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
12446 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12447 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
12448 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
12449 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
12450 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12451 }
12452 }
12453 }
12454 deserializer.deserialize_identifier(GeneratedVisitor)
12455 }
12456 }
12457 struct GeneratedVisitor;
12458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12459 type Value = StreamScanNode;
12460
12461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12462 formatter.write_str("struct stream_plan.StreamScanNode")
12463 }
12464
12465 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
12466 where
12467 V: serde::de::MapAccess<'de>,
12468 {
12469 let mut table_id__ = None;
12470 let mut upstream_column_ids__ = None;
12471 let mut output_indices__ = None;
12472 let mut stream_scan_type__ = None;
12473 let mut state_table__ = None;
12474 let mut table_desc__ = None;
12475 let mut rate_limit__ = None;
12476 let mut snapshot_read_barrier_interval__ = None;
12477 let mut arrangement_table__ = None;
12478 let mut snapshot_backfill_epoch__ = None;
12479 while let Some(k) = map_.next_key()? {
12480 match k {
12481 GeneratedField::TableId => {
12482 if table_id__.is_some() {
12483 return Err(serde::de::Error::duplicate_field("tableId"));
12484 }
12485 table_id__ =
12486 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12487 ;
12488 }
12489 GeneratedField::UpstreamColumnIds => {
12490 if upstream_column_ids__.is_some() {
12491 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12492 }
12493 upstream_column_ids__ =
12494 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12495 .into_iter().map(|x| x.0).collect())
12496 ;
12497 }
12498 GeneratedField::OutputIndices => {
12499 if output_indices__.is_some() {
12500 return Err(serde::de::Error::duplicate_field("outputIndices"));
12501 }
12502 output_indices__ =
12503 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12504 .into_iter().map(|x| x.0).collect())
12505 ;
12506 }
12507 GeneratedField::StreamScanType => {
12508 if stream_scan_type__.is_some() {
12509 return Err(serde::de::Error::duplicate_field("streamScanType"));
12510 }
12511 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
12512 }
12513 GeneratedField::StateTable => {
12514 if state_table__.is_some() {
12515 return Err(serde::de::Error::duplicate_field("stateTable"));
12516 }
12517 state_table__ = map_.next_value()?;
12518 }
12519 GeneratedField::TableDesc => {
12520 if table_desc__.is_some() {
12521 return Err(serde::de::Error::duplicate_field("tableDesc"));
12522 }
12523 table_desc__ = map_.next_value()?;
12524 }
12525 GeneratedField::RateLimit => {
12526 if rate_limit__.is_some() {
12527 return Err(serde::de::Error::duplicate_field("rateLimit"));
12528 }
12529 rate_limit__ =
12530 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12531 ;
12532 }
12533 GeneratedField::SnapshotReadBarrierInterval => {
12534 if snapshot_read_barrier_interval__.is_some() {
12535 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
12536 }
12537 snapshot_read_barrier_interval__ =
12538 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12539 ;
12540 }
12541 GeneratedField::ArrangementTable => {
12542 if arrangement_table__.is_some() {
12543 return Err(serde::de::Error::duplicate_field("arrangementTable"));
12544 }
12545 arrangement_table__ = map_.next_value()?;
12546 }
12547 GeneratedField::SnapshotBackfillEpoch => {
12548 if snapshot_backfill_epoch__.is_some() {
12549 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
12550 }
12551 snapshot_backfill_epoch__ =
12552 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12553 ;
12554 }
12555 }
12556 }
12557 Ok(StreamScanNode {
12558 table_id: table_id__.unwrap_or_default(),
12559 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12560 output_indices: output_indices__.unwrap_or_default(),
12561 stream_scan_type: stream_scan_type__.unwrap_or_default(),
12562 state_table: state_table__,
12563 table_desc: table_desc__,
12564 rate_limit: rate_limit__,
12565 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
12566 arrangement_table: arrangement_table__,
12567 snapshot_backfill_epoch: snapshot_backfill_epoch__,
12568 })
12569 }
12570 }
12571 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
12572 }
12573}
12574impl serde::Serialize for StreamScanType {
12575 #[allow(deprecated)]
12576 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12577 where
12578 S: serde::Serializer,
12579 {
12580 let variant = match self {
12581 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
12582 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
12583 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
12584 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
12585 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12586 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12587 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12588 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12589 };
12590 serializer.serialize_str(variant)
12591 }
12592}
12593impl<'de> serde::Deserialize<'de> for StreamScanType {
12594 #[allow(deprecated)]
12595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12596 where
12597 D: serde::Deserializer<'de>,
12598 {
12599 const FIELDS: &[&str] = &[
12600 "STREAM_SCAN_TYPE_UNSPECIFIED",
12601 "STREAM_SCAN_TYPE_CHAIN",
12602 "STREAM_SCAN_TYPE_REARRANGE",
12603 "STREAM_SCAN_TYPE_BACKFILL",
12604 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12605 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12606 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12607 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12608 ];
12609
12610 struct GeneratedVisitor;
12611
12612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12613 type Value = StreamScanType;
12614
12615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12616 write!(formatter, "expected one of: {:?}", &FIELDS)
12617 }
12618
12619 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12620 where
12621 E: serde::de::Error,
12622 {
12623 i32::try_from(v)
12624 .ok()
12625 .and_then(|x| x.try_into().ok())
12626 .ok_or_else(|| {
12627 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12628 })
12629 }
12630
12631 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12632 where
12633 E: serde::de::Error,
12634 {
12635 i32::try_from(v)
12636 .ok()
12637 .and_then(|x| x.try_into().ok())
12638 .ok_or_else(|| {
12639 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12640 })
12641 }
12642
12643 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12644 where
12645 E: serde::de::Error,
12646 {
12647 match value {
12648 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
12649 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
12650 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
12651 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
12652 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
12653 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
12654 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
12655 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
12656 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12657 }
12658 }
12659 }
12660 deserializer.deserialize_any(GeneratedVisitor)
12661 }
12662}
12663impl serde::Serialize for StreamSource {
12664 #[allow(deprecated)]
12665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12666 where
12667 S: serde::Serializer,
12668 {
12669 use serde::ser::SerializeStruct;
12670 let mut len = 0;
12671 if self.source_id != 0 {
12672 len += 1;
12673 }
12674 if self.state_table.is_some() {
12675 len += 1;
12676 }
12677 if self.row_id_index.is_some() {
12678 len += 1;
12679 }
12680 if !self.columns.is_empty() {
12681 len += 1;
12682 }
12683 if !self.with_properties.is_empty() {
12684 len += 1;
12685 }
12686 if self.info.is_some() {
12687 len += 1;
12688 }
12689 if !self.source_name.is_empty() {
12690 len += 1;
12691 }
12692 if self.rate_limit.is_some() {
12693 len += 1;
12694 }
12695 if !self.secret_refs.is_empty() {
12696 len += 1;
12697 }
12698 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
12699 if self.source_id != 0 {
12700 struct_ser.serialize_field("sourceId", &self.source_id)?;
12701 }
12702 if let Some(v) = self.state_table.as_ref() {
12703 struct_ser.serialize_field("stateTable", v)?;
12704 }
12705 if let Some(v) = self.row_id_index.as_ref() {
12706 struct_ser.serialize_field("rowIdIndex", v)?;
12707 }
12708 if !self.columns.is_empty() {
12709 struct_ser.serialize_field("columns", &self.columns)?;
12710 }
12711 if !self.with_properties.is_empty() {
12712 struct_ser.serialize_field("withProperties", &self.with_properties)?;
12713 }
12714 if let Some(v) = self.info.as_ref() {
12715 struct_ser.serialize_field("info", v)?;
12716 }
12717 if !self.source_name.is_empty() {
12718 struct_ser.serialize_field("sourceName", &self.source_name)?;
12719 }
12720 if let Some(v) = self.rate_limit.as_ref() {
12721 struct_ser.serialize_field("rateLimit", v)?;
12722 }
12723 if !self.secret_refs.is_empty() {
12724 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
12725 }
12726 struct_ser.end()
12727 }
12728}
12729impl<'de> serde::Deserialize<'de> for StreamSource {
12730 #[allow(deprecated)]
12731 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12732 where
12733 D: serde::Deserializer<'de>,
12734 {
12735 const FIELDS: &[&str] = &[
12736 "source_id",
12737 "sourceId",
12738 "state_table",
12739 "stateTable",
12740 "row_id_index",
12741 "rowIdIndex",
12742 "columns",
12743 "with_properties",
12744 "withProperties",
12745 "info",
12746 "source_name",
12747 "sourceName",
12748 "rate_limit",
12749 "rateLimit",
12750 "secret_refs",
12751 "secretRefs",
12752 ];
12753
12754 #[allow(clippy::enum_variant_names)]
12755 enum GeneratedField {
12756 SourceId,
12757 StateTable,
12758 RowIdIndex,
12759 Columns,
12760 WithProperties,
12761 Info,
12762 SourceName,
12763 RateLimit,
12764 SecretRefs,
12765 }
12766 impl<'de> serde::Deserialize<'de> for GeneratedField {
12767 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12768 where
12769 D: serde::Deserializer<'de>,
12770 {
12771 struct GeneratedVisitor;
12772
12773 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12774 type Value = GeneratedField;
12775
12776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12777 write!(formatter, "expected one of: {:?}", &FIELDS)
12778 }
12779
12780 #[allow(unused_variables)]
12781 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12782 where
12783 E: serde::de::Error,
12784 {
12785 match value {
12786 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12787 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12788 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12789 "columns" => Ok(GeneratedField::Columns),
12790 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
12791 "info" => Ok(GeneratedField::Info),
12792 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
12793 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12794 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
12795 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12796 }
12797 }
12798 }
12799 deserializer.deserialize_identifier(GeneratedVisitor)
12800 }
12801 }
12802 struct GeneratedVisitor;
12803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12804 type Value = StreamSource;
12805
12806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12807 formatter.write_str("struct stream_plan.StreamSource")
12808 }
12809
12810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
12811 where
12812 V: serde::de::MapAccess<'de>,
12813 {
12814 let mut source_id__ = None;
12815 let mut state_table__ = None;
12816 let mut row_id_index__ = None;
12817 let mut columns__ = None;
12818 let mut with_properties__ = None;
12819 let mut info__ = None;
12820 let mut source_name__ = None;
12821 let mut rate_limit__ = None;
12822 let mut secret_refs__ = None;
12823 while let Some(k) = map_.next_key()? {
12824 match k {
12825 GeneratedField::SourceId => {
12826 if source_id__.is_some() {
12827 return Err(serde::de::Error::duplicate_field("sourceId"));
12828 }
12829 source_id__ =
12830 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12831 ;
12832 }
12833 GeneratedField::StateTable => {
12834 if state_table__.is_some() {
12835 return Err(serde::de::Error::duplicate_field("stateTable"));
12836 }
12837 state_table__ = map_.next_value()?;
12838 }
12839 GeneratedField::RowIdIndex => {
12840 if row_id_index__.is_some() {
12841 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12842 }
12843 row_id_index__ =
12844 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12845 ;
12846 }
12847 GeneratedField::Columns => {
12848 if columns__.is_some() {
12849 return Err(serde::de::Error::duplicate_field("columns"));
12850 }
12851 columns__ = Some(map_.next_value()?);
12852 }
12853 GeneratedField::WithProperties => {
12854 if with_properties__.is_some() {
12855 return Err(serde::de::Error::duplicate_field("withProperties"));
12856 }
12857 with_properties__ = Some(
12858 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12859 );
12860 }
12861 GeneratedField::Info => {
12862 if info__.is_some() {
12863 return Err(serde::de::Error::duplicate_field("info"));
12864 }
12865 info__ = map_.next_value()?;
12866 }
12867 GeneratedField::SourceName => {
12868 if source_name__.is_some() {
12869 return Err(serde::de::Error::duplicate_field("sourceName"));
12870 }
12871 source_name__ = Some(map_.next_value()?);
12872 }
12873 GeneratedField::RateLimit => {
12874 if rate_limit__.is_some() {
12875 return Err(serde::de::Error::duplicate_field("rateLimit"));
12876 }
12877 rate_limit__ =
12878 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12879 ;
12880 }
12881 GeneratedField::SecretRefs => {
12882 if secret_refs__.is_some() {
12883 return Err(serde::de::Error::duplicate_field("secretRefs"));
12884 }
12885 secret_refs__ = Some(
12886 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12887 );
12888 }
12889 }
12890 }
12891 Ok(StreamSource {
12892 source_id: source_id__.unwrap_or_default(),
12893 state_table: state_table__,
12894 row_id_index: row_id_index__,
12895 columns: columns__.unwrap_or_default(),
12896 with_properties: with_properties__.unwrap_or_default(),
12897 info: info__,
12898 source_name: source_name__.unwrap_or_default(),
12899 rate_limit: rate_limit__,
12900 secret_refs: secret_refs__.unwrap_or_default(),
12901 })
12902 }
12903 }
12904 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
12905 }
12906}
12907impl serde::Serialize for SubscriptionUpstreamInfo {
12908 #[allow(deprecated)]
12909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12910 where
12911 S: serde::Serializer,
12912 {
12913 use serde::ser::SerializeStruct;
12914 let mut len = 0;
12915 if self.subscriber_id != 0 {
12916 len += 1;
12917 }
12918 if self.upstream_mv_table_id != 0 {
12919 len += 1;
12920 }
12921 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
12922 if self.subscriber_id != 0 {
12923 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
12924 }
12925 if self.upstream_mv_table_id != 0 {
12926 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
12927 }
12928 struct_ser.end()
12929 }
12930}
12931impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
12932 #[allow(deprecated)]
12933 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12934 where
12935 D: serde::Deserializer<'de>,
12936 {
12937 const FIELDS: &[&str] = &[
12938 "subscriber_id",
12939 "subscriberId",
12940 "upstream_mv_table_id",
12941 "upstreamMvTableId",
12942 ];
12943
12944 #[allow(clippy::enum_variant_names)]
12945 enum GeneratedField {
12946 SubscriberId,
12947 UpstreamMvTableId,
12948 }
12949 impl<'de> serde::Deserialize<'de> for GeneratedField {
12950 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12951 where
12952 D: serde::Deserializer<'de>,
12953 {
12954 struct GeneratedVisitor;
12955
12956 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12957 type Value = GeneratedField;
12958
12959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12960 write!(formatter, "expected one of: {:?}", &FIELDS)
12961 }
12962
12963 #[allow(unused_variables)]
12964 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12965 where
12966 E: serde::de::Error,
12967 {
12968 match value {
12969 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
12970 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
12971 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12972 }
12973 }
12974 }
12975 deserializer.deserialize_identifier(GeneratedVisitor)
12976 }
12977 }
12978 struct GeneratedVisitor;
12979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12980 type Value = SubscriptionUpstreamInfo;
12981
12982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12983 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
12984 }
12985
12986 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
12987 where
12988 V: serde::de::MapAccess<'de>,
12989 {
12990 let mut subscriber_id__ = None;
12991 let mut upstream_mv_table_id__ = None;
12992 while let Some(k) = map_.next_key()? {
12993 match k {
12994 GeneratedField::SubscriberId => {
12995 if subscriber_id__.is_some() {
12996 return Err(serde::de::Error::duplicate_field("subscriberId"));
12997 }
12998 subscriber_id__ =
12999 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13000 ;
13001 }
13002 GeneratedField::UpstreamMvTableId => {
13003 if upstream_mv_table_id__.is_some() {
13004 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13005 }
13006 upstream_mv_table_id__ =
13007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13008 ;
13009 }
13010 }
13011 }
13012 Ok(SubscriptionUpstreamInfo {
13013 subscriber_id: subscriber_id__.unwrap_or_default(),
13014 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13015 })
13016 }
13017 }
13018 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13019 }
13020}
13021impl serde::Serialize for SyncLogStoreNode {
13022 #[allow(deprecated)]
13023 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13024 where
13025 S: serde::Serializer,
13026 {
13027 use serde::ser::SerializeStruct;
13028 let mut len = 0;
13029 if self.log_store_table.is_some() {
13030 len += 1;
13031 }
13032 if self.pause_duration_ms != 0 {
13033 len += 1;
13034 }
13035 if self.buffer_size != 0 {
13036 len += 1;
13037 }
13038 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13039 if let Some(v) = self.log_store_table.as_ref() {
13040 struct_ser.serialize_field("logStoreTable", v)?;
13041 }
13042 if self.pause_duration_ms != 0 {
13043 struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13044 }
13045 if self.buffer_size != 0 {
13046 struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13047 }
13048 struct_ser.end()
13049 }
13050}
13051impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13052 #[allow(deprecated)]
13053 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13054 where
13055 D: serde::Deserializer<'de>,
13056 {
13057 const FIELDS: &[&str] = &[
13058 "log_store_table",
13059 "logStoreTable",
13060 "pause_duration_ms",
13061 "pauseDurationMs",
13062 "buffer_size",
13063 "bufferSize",
13064 ];
13065
13066 #[allow(clippy::enum_variant_names)]
13067 enum GeneratedField {
13068 LogStoreTable,
13069 PauseDurationMs,
13070 BufferSize,
13071 }
13072 impl<'de> serde::Deserialize<'de> for GeneratedField {
13073 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13074 where
13075 D: serde::Deserializer<'de>,
13076 {
13077 struct GeneratedVisitor;
13078
13079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13080 type Value = GeneratedField;
13081
13082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13083 write!(formatter, "expected one of: {:?}", &FIELDS)
13084 }
13085
13086 #[allow(unused_variables)]
13087 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13088 where
13089 E: serde::de::Error,
13090 {
13091 match value {
13092 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
13093 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
13094 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
13095 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13096 }
13097 }
13098 }
13099 deserializer.deserialize_identifier(GeneratedVisitor)
13100 }
13101 }
13102 struct GeneratedVisitor;
13103 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13104 type Value = SyncLogStoreNode;
13105
13106 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13107 formatter.write_str("struct stream_plan.SyncLogStoreNode")
13108 }
13109
13110 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
13111 where
13112 V: serde::de::MapAccess<'de>,
13113 {
13114 let mut log_store_table__ = None;
13115 let mut pause_duration_ms__ = None;
13116 let mut buffer_size__ = None;
13117 while let Some(k) = map_.next_key()? {
13118 match k {
13119 GeneratedField::LogStoreTable => {
13120 if log_store_table__.is_some() {
13121 return Err(serde::de::Error::duplicate_field("logStoreTable"));
13122 }
13123 log_store_table__ = map_.next_value()?;
13124 }
13125 GeneratedField::PauseDurationMs => {
13126 if pause_duration_ms__.is_some() {
13127 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
13128 }
13129 pause_duration_ms__ =
13130 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13131 ;
13132 }
13133 GeneratedField::BufferSize => {
13134 if buffer_size__.is_some() {
13135 return Err(serde::de::Error::duplicate_field("bufferSize"));
13136 }
13137 buffer_size__ =
13138 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13139 ;
13140 }
13141 }
13142 }
13143 Ok(SyncLogStoreNode {
13144 log_store_table: log_store_table__,
13145 pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
13146 buffer_size: buffer_size__.unwrap_or_default(),
13147 })
13148 }
13149 }
13150 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
13151 }
13152}
13153impl serde::Serialize for TemporalJoinNode {
13154 #[allow(deprecated)]
13155 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13156 where
13157 S: serde::Serializer,
13158 {
13159 use serde::ser::SerializeStruct;
13160 let mut len = 0;
13161 if self.join_type != 0 {
13162 len += 1;
13163 }
13164 if !self.left_key.is_empty() {
13165 len += 1;
13166 }
13167 if !self.right_key.is_empty() {
13168 len += 1;
13169 }
13170 if !self.null_safe.is_empty() {
13171 len += 1;
13172 }
13173 if self.condition.is_some() {
13174 len += 1;
13175 }
13176 if !self.output_indices.is_empty() {
13177 len += 1;
13178 }
13179 if self.table_desc.is_some() {
13180 len += 1;
13181 }
13182 if !self.table_output_indices.is_empty() {
13183 len += 1;
13184 }
13185 if self.memo_table.is_some() {
13186 len += 1;
13187 }
13188 if self.is_nested_loop {
13189 len += 1;
13190 }
13191 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
13192 if self.join_type != 0 {
13193 let v = super::plan_common::JoinType::try_from(self.join_type)
13194 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
13195 struct_ser.serialize_field("joinType", &v)?;
13196 }
13197 if !self.left_key.is_empty() {
13198 struct_ser.serialize_field("leftKey", &self.left_key)?;
13199 }
13200 if !self.right_key.is_empty() {
13201 struct_ser.serialize_field("rightKey", &self.right_key)?;
13202 }
13203 if !self.null_safe.is_empty() {
13204 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
13205 }
13206 if let Some(v) = self.condition.as_ref() {
13207 struct_ser.serialize_field("condition", v)?;
13208 }
13209 if !self.output_indices.is_empty() {
13210 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13211 }
13212 if let Some(v) = self.table_desc.as_ref() {
13213 struct_ser.serialize_field("tableDesc", v)?;
13214 }
13215 if !self.table_output_indices.is_empty() {
13216 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
13217 }
13218 if let Some(v) = self.memo_table.as_ref() {
13219 struct_ser.serialize_field("memoTable", v)?;
13220 }
13221 if self.is_nested_loop {
13222 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
13223 }
13224 struct_ser.end()
13225 }
13226}
13227impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
13228 #[allow(deprecated)]
13229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13230 where
13231 D: serde::Deserializer<'de>,
13232 {
13233 const FIELDS: &[&str] = &[
13234 "join_type",
13235 "joinType",
13236 "left_key",
13237 "leftKey",
13238 "right_key",
13239 "rightKey",
13240 "null_safe",
13241 "nullSafe",
13242 "condition",
13243 "output_indices",
13244 "outputIndices",
13245 "table_desc",
13246 "tableDesc",
13247 "table_output_indices",
13248 "tableOutputIndices",
13249 "memo_table",
13250 "memoTable",
13251 "is_nested_loop",
13252 "isNestedLoop",
13253 ];
13254
13255 #[allow(clippy::enum_variant_names)]
13256 enum GeneratedField {
13257 JoinType,
13258 LeftKey,
13259 RightKey,
13260 NullSafe,
13261 Condition,
13262 OutputIndices,
13263 TableDesc,
13264 TableOutputIndices,
13265 MemoTable,
13266 IsNestedLoop,
13267 }
13268 impl<'de> serde::Deserialize<'de> for GeneratedField {
13269 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13270 where
13271 D: serde::Deserializer<'de>,
13272 {
13273 struct GeneratedVisitor;
13274
13275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13276 type Value = GeneratedField;
13277
13278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13279 write!(formatter, "expected one of: {:?}", &FIELDS)
13280 }
13281
13282 #[allow(unused_variables)]
13283 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13284 where
13285 E: serde::de::Error,
13286 {
13287 match value {
13288 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
13289 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
13290 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
13291 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
13292 "condition" => Ok(GeneratedField::Condition),
13293 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13294 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13295 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
13296 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
13297 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
13298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13299 }
13300 }
13301 }
13302 deserializer.deserialize_identifier(GeneratedVisitor)
13303 }
13304 }
13305 struct GeneratedVisitor;
13306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13307 type Value = TemporalJoinNode;
13308
13309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13310 formatter.write_str("struct stream_plan.TemporalJoinNode")
13311 }
13312
13313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
13314 where
13315 V: serde::de::MapAccess<'de>,
13316 {
13317 let mut join_type__ = None;
13318 let mut left_key__ = None;
13319 let mut right_key__ = None;
13320 let mut null_safe__ = None;
13321 let mut condition__ = None;
13322 let mut output_indices__ = None;
13323 let mut table_desc__ = None;
13324 let mut table_output_indices__ = None;
13325 let mut memo_table__ = None;
13326 let mut is_nested_loop__ = None;
13327 while let Some(k) = map_.next_key()? {
13328 match k {
13329 GeneratedField::JoinType => {
13330 if join_type__.is_some() {
13331 return Err(serde::de::Error::duplicate_field("joinType"));
13332 }
13333 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
13334 }
13335 GeneratedField::LeftKey => {
13336 if left_key__.is_some() {
13337 return Err(serde::de::Error::duplicate_field("leftKey"));
13338 }
13339 left_key__ =
13340 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13341 .into_iter().map(|x| x.0).collect())
13342 ;
13343 }
13344 GeneratedField::RightKey => {
13345 if right_key__.is_some() {
13346 return Err(serde::de::Error::duplicate_field("rightKey"));
13347 }
13348 right_key__ =
13349 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13350 .into_iter().map(|x| x.0).collect())
13351 ;
13352 }
13353 GeneratedField::NullSafe => {
13354 if null_safe__.is_some() {
13355 return Err(serde::de::Error::duplicate_field("nullSafe"));
13356 }
13357 null_safe__ = Some(map_.next_value()?);
13358 }
13359 GeneratedField::Condition => {
13360 if condition__.is_some() {
13361 return Err(serde::de::Error::duplicate_field("condition"));
13362 }
13363 condition__ = map_.next_value()?;
13364 }
13365 GeneratedField::OutputIndices => {
13366 if output_indices__.is_some() {
13367 return Err(serde::de::Error::duplicate_field("outputIndices"));
13368 }
13369 output_indices__ =
13370 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13371 .into_iter().map(|x| x.0).collect())
13372 ;
13373 }
13374 GeneratedField::TableDesc => {
13375 if table_desc__.is_some() {
13376 return Err(serde::de::Error::duplicate_field("tableDesc"));
13377 }
13378 table_desc__ = map_.next_value()?;
13379 }
13380 GeneratedField::TableOutputIndices => {
13381 if table_output_indices__.is_some() {
13382 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
13383 }
13384 table_output_indices__ =
13385 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13386 .into_iter().map(|x| x.0).collect())
13387 ;
13388 }
13389 GeneratedField::MemoTable => {
13390 if memo_table__.is_some() {
13391 return Err(serde::de::Error::duplicate_field("memoTable"));
13392 }
13393 memo_table__ = map_.next_value()?;
13394 }
13395 GeneratedField::IsNestedLoop => {
13396 if is_nested_loop__.is_some() {
13397 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
13398 }
13399 is_nested_loop__ = Some(map_.next_value()?);
13400 }
13401 }
13402 }
13403 Ok(TemporalJoinNode {
13404 join_type: join_type__.unwrap_or_default(),
13405 left_key: left_key__.unwrap_or_default(),
13406 right_key: right_key__.unwrap_or_default(),
13407 null_safe: null_safe__.unwrap_or_default(),
13408 condition: condition__,
13409 output_indices: output_indices__.unwrap_or_default(),
13410 table_desc: table_desc__,
13411 table_output_indices: table_output_indices__.unwrap_or_default(),
13412 memo_table: memo_table__,
13413 is_nested_loop: is_nested_loop__.unwrap_or_default(),
13414 })
13415 }
13416 }
13417 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
13418 }
13419}
13420impl serde::Serialize for ThrottleMutation {
13421 #[allow(deprecated)]
13422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13423 where
13424 S: serde::Serializer,
13425 {
13426 use serde::ser::SerializeStruct;
13427 let mut len = 0;
13428 if !self.actor_throttle.is_empty() {
13429 len += 1;
13430 }
13431 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
13432 if !self.actor_throttle.is_empty() {
13433 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
13434 }
13435 struct_ser.end()
13436 }
13437}
13438impl<'de> serde::Deserialize<'de> for ThrottleMutation {
13439 #[allow(deprecated)]
13440 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13441 where
13442 D: serde::Deserializer<'de>,
13443 {
13444 const FIELDS: &[&str] = &[
13445 "actor_throttle",
13446 "actorThrottle",
13447 ];
13448
13449 #[allow(clippy::enum_variant_names)]
13450 enum GeneratedField {
13451 ActorThrottle,
13452 }
13453 impl<'de> serde::Deserialize<'de> for GeneratedField {
13454 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13455 where
13456 D: serde::Deserializer<'de>,
13457 {
13458 struct GeneratedVisitor;
13459
13460 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13461 type Value = GeneratedField;
13462
13463 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13464 write!(formatter, "expected one of: {:?}", &FIELDS)
13465 }
13466
13467 #[allow(unused_variables)]
13468 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13469 where
13470 E: serde::de::Error,
13471 {
13472 match value {
13473 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
13474 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13475 }
13476 }
13477 }
13478 deserializer.deserialize_identifier(GeneratedVisitor)
13479 }
13480 }
13481 struct GeneratedVisitor;
13482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13483 type Value = ThrottleMutation;
13484
13485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13486 formatter.write_str("struct stream_plan.ThrottleMutation")
13487 }
13488
13489 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
13490 where
13491 V: serde::de::MapAccess<'de>,
13492 {
13493 let mut actor_throttle__ = None;
13494 while let Some(k) = map_.next_key()? {
13495 match k {
13496 GeneratedField::ActorThrottle => {
13497 if actor_throttle__.is_some() {
13498 return Err(serde::de::Error::duplicate_field("actorThrottle"));
13499 }
13500 actor_throttle__ = Some(
13501 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13502 .into_iter().map(|(k,v)| (k.0, v)).collect()
13503 );
13504 }
13505 }
13506 }
13507 Ok(ThrottleMutation {
13508 actor_throttle: actor_throttle__.unwrap_or_default(),
13509 })
13510 }
13511 }
13512 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
13513 }
13514}
13515impl serde::Serialize for throttle_mutation::RateLimit {
13516 #[allow(deprecated)]
13517 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13518 where
13519 S: serde::Serializer,
13520 {
13521 use serde::ser::SerializeStruct;
13522 let mut len = 0;
13523 if self.rate_limit.is_some() {
13524 len += 1;
13525 }
13526 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
13527 if let Some(v) = self.rate_limit.as_ref() {
13528 struct_ser.serialize_field("rateLimit", v)?;
13529 }
13530 struct_ser.end()
13531 }
13532}
13533impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
13534 #[allow(deprecated)]
13535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13536 where
13537 D: serde::Deserializer<'de>,
13538 {
13539 const FIELDS: &[&str] = &[
13540 "rate_limit",
13541 "rateLimit",
13542 ];
13543
13544 #[allow(clippy::enum_variant_names)]
13545 enum GeneratedField {
13546 RateLimit,
13547 }
13548 impl<'de> serde::Deserialize<'de> for GeneratedField {
13549 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13550 where
13551 D: serde::Deserializer<'de>,
13552 {
13553 struct GeneratedVisitor;
13554
13555 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13556 type Value = GeneratedField;
13557
13558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13559 write!(formatter, "expected one of: {:?}", &FIELDS)
13560 }
13561
13562 #[allow(unused_variables)]
13563 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13564 where
13565 E: serde::de::Error,
13566 {
13567 match value {
13568 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13569 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13570 }
13571 }
13572 }
13573 deserializer.deserialize_identifier(GeneratedVisitor)
13574 }
13575 }
13576 struct GeneratedVisitor;
13577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13578 type Value = throttle_mutation::RateLimit;
13579
13580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13581 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
13582 }
13583
13584 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
13585 where
13586 V: serde::de::MapAccess<'de>,
13587 {
13588 let mut rate_limit__ = None;
13589 while let Some(k) = map_.next_key()? {
13590 match k {
13591 GeneratedField::RateLimit => {
13592 if rate_limit__.is_some() {
13593 return Err(serde::de::Error::duplicate_field("rateLimit"));
13594 }
13595 rate_limit__ =
13596 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13597 ;
13598 }
13599 }
13600 }
13601 Ok(throttle_mutation::RateLimit {
13602 rate_limit: rate_limit__,
13603 })
13604 }
13605 }
13606 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
13607 }
13608}
13609impl serde::Serialize for TopNNode {
13610 #[allow(deprecated)]
13611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13612 where
13613 S: serde::Serializer,
13614 {
13615 use serde::ser::SerializeStruct;
13616 let mut len = 0;
13617 if self.limit != 0 {
13618 len += 1;
13619 }
13620 if self.offset != 0 {
13621 len += 1;
13622 }
13623 if self.table.is_some() {
13624 len += 1;
13625 }
13626 if !self.order_by.is_empty() {
13627 len += 1;
13628 }
13629 if self.with_ties {
13630 len += 1;
13631 }
13632 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
13633 if self.limit != 0 {
13634 #[allow(clippy::needless_borrow)]
13635 #[allow(clippy::needless_borrows_for_generic_args)]
13636 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
13637 }
13638 if self.offset != 0 {
13639 #[allow(clippy::needless_borrow)]
13640 #[allow(clippy::needless_borrows_for_generic_args)]
13641 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
13642 }
13643 if let Some(v) = self.table.as_ref() {
13644 struct_ser.serialize_field("table", v)?;
13645 }
13646 if !self.order_by.is_empty() {
13647 struct_ser.serialize_field("orderBy", &self.order_by)?;
13648 }
13649 if self.with_ties {
13650 struct_ser.serialize_field("withTies", &self.with_ties)?;
13651 }
13652 struct_ser.end()
13653 }
13654}
13655impl<'de> serde::Deserialize<'de> for TopNNode {
13656 #[allow(deprecated)]
13657 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13658 where
13659 D: serde::Deserializer<'de>,
13660 {
13661 const FIELDS: &[&str] = &[
13662 "limit",
13663 "offset",
13664 "table",
13665 "order_by",
13666 "orderBy",
13667 "with_ties",
13668 "withTies",
13669 ];
13670
13671 #[allow(clippy::enum_variant_names)]
13672 enum GeneratedField {
13673 Limit,
13674 Offset,
13675 Table,
13676 OrderBy,
13677 WithTies,
13678 }
13679 impl<'de> serde::Deserialize<'de> for GeneratedField {
13680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13681 where
13682 D: serde::Deserializer<'de>,
13683 {
13684 struct GeneratedVisitor;
13685
13686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13687 type Value = GeneratedField;
13688
13689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13690 write!(formatter, "expected one of: {:?}", &FIELDS)
13691 }
13692
13693 #[allow(unused_variables)]
13694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13695 where
13696 E: serde::de::Error,
13697 {
13698 match value {
13699 "limit" => Ok(GeneratedField::Limit),
13700 "offset" => Ok(GeneratedField::Offset),
13701 "table" => Ok(GeneratedField::Table),
13702 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
13703 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
13704 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13705 }
13706 }
13707 }
13708 deserializer.deserialize_identifier(GeneratedVisitor)
13709 }
13710 }
13711 struct GeneratedVisitor;
13712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13713 type Value = TopNNode;
13714
13715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13716 formatter.write_str("struct stream_plan.TopNNode")
13717 }
13718
13719 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
13720 where
13721 V: serde::de::MapAccess<'de>,
13722 {
13723 let mut limit__ = None;
13724 let mut offset__ = None;
13725 let mut table__ = None;
13726 let mut order_by__ = None;
13727 let mut with_ties__ = None;
13728 while let Some(k) = map_.next_key()? {
13729 match k {
13730 GeneratedField::Limit => {
13731 if limit__.is_some() {
13732 return Err(serde::de::Error::duplicate_field("limit"));
13733 }
13734 limit__ =
13735 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13736 ;
13737 }
13738 GeneratedField::Offset => {
13739 if offset__.is_some() {
13740 return Err(serde::de::Error::duplicate_field("offset"));
13741 }
13742 offset__ =
13743 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13744 ;
13745 }
13746 GeneratedField::Table => {
13747 if table__.is_some() {
13748 return Err(serde::de::Error::duplicate_field("table"));
13749 }
13750 table__ = map_.next_value()?;
13751 }
13752 GeneratedField::OrderBy => {
13753 if order_by__.is_some() {
13754 return Err(serde::de::Error::duplicate_field("orderBy"));
13755 }
13756 order_by__ = Some(map_.next_value()?);
13757 }
13758 GeneratedField::WithTies => {
13759 if with_ties__.is_some() {
13760 return Err(serde::de::Error::duplicate_field("withTies"));
13761 }
13762 with_ties__ = Some(map_.next_value()?);
13763 }
13764 }
13765 }
13766 Ok(TopNNode {
13767 limit: limit__.unwrap_or_default(),
13768 offset: offset__.unwrap_or_default(),
13769 table: table__,
13770 order_by: order_by__.unwrap_or_default(),
13771 with_ties: with_ties__.unwrap_or_default(),
13772 })
13773 }
13774 }
13775 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
13776 }
13777}
13778impl serde::Serialize for UnionNode {
13779 #[allow(deprecated)]
13780 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13781 where
13782 S: serde::Serializer,
13783 {
13784 use serde::ser::SerializeStruct;
13785 let len = 0;
13786 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
13787 struct_ser.end()
13788 }
13789}
13790impl<'de> serde::Deserialize<'de> for UnionNode {
13791 #[allow(deprecated)]
13792 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13793 where
13794 D: serde::Deserializer<'de>,
13795 {
13796 const FIELDS: &[&str] = &[
13797 ];
13798
13799 #[allow(clippy::enum_variant_names)]
13800 enum GeneratedField {
13801 }
13802 impl<'de> serde::Deserialize<'de> for GeneratedField {
13803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13804 where
13805 D: serde::Deserializer<'de>,
13806 {
13807 struct GeneratedVisitor;
13808
13809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13810 type Value = GeneratedField;
13811
13812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13813 write!(formatter, "expected one of: {:?}", &FIELDS)
13814 }
13815
13816 #[allow(unused_variables)]
13817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13818 where
13819 E: serde::de::Error,
13820 {
13821 Err(serde::de::Error::unknown_field(value, FIELDS))
13822 }
13823 }
13824 deserializer.deserialize_identifier(GeneratedVisitor)
13825 }
13826 }
13827 struct GeneratedVisitor;
13828 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13829 type Value = UnionNode;
13830
13831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13832 formatter.write_str("struct stream_plan.UnionNode")
13833 }
13834
13835 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
13836 where
13837 V: serde::de::MapAccess<'de>,
13838 {
13839 while map_.next_key::<GeneratedField>()?.is_some() {
13840 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13841 }
13842 Ok(UnionNode {
13843 })
13844 }
13845 }
13846 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
13847 }
13848}
13849impl serde::Serialize for UpdateMutation {
13850 #[allow(deprecated)]
13851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13852 where
13853 S: serde::Serializer,
13854 {
13855 use serde::ser::SerializeStruct;
13856 let mut len = 0;
13857 if !self.dispatcher_update.is_empty() {
13858 len += 1;
13859 }
13860 if !self.merge_update.is_empty() {
13861 len += 1;
13862 }
13863 if !self.actor_vnode_bitmap_update.is_empty() {
13864 len += 1;
13865 }
13866 if !self.dropped_actors.is_empty() {
13867 len += 1;
13868 }
13869 if !self.actor_splits.is_empty() {
13870 len += 1;
13871 }
13872 if !self.actor_new_dispatchers.is_empty() {
13873 len += 1;
13874 }
13875 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
13876 if !self.dispatcher_update.is_empty() {
13877 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
13878 }
13879 if !self.merge_update.is_empty() {
13880 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
13881 }
13882 if !self.actor_vnode_bitmap_update.is_empty() {
13883 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
13884 }
13885 if !self.dropped_actors.is_empty() {
13886 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
13887 }
13888 if !self.actor_splits.is_empty() {
13889 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
13890 }
13891 if !self.actor_new_dispatchers.is_empty() {
13892 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
13893 }
13894 struct_ser.end()
13895 }
13896}
13897impl<'de> serde::Deserialize<'de> for UpdateMutation {
13898 #[allow(deprecated)]
13899 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13900 where
13901 D: serde::Deserializer<'de>,
13902 {
13903 const FIELDS: &[&str] = &[
13904 "dispatcher_update",
13905 "dispatcherUpdate",
13906 "merge_update",
13907 "mergeUpdate",
13908 "actor_vnode_bitmap_update",
13909 "actorVnodeBitmapUpdate",
13910 "dropped_actors",
13911 "droppedActors",
13912 "actor_splits",
13913 "actorSplits",
13914 "actor_new_dispatchers",
13915 "actorNewDispatchers",
13916 ];
13917
13918 #[allow(clippy::enum_variant_names)]
13919 enum GeneratedField {
13920 DispatcherUpdate,
13921 MergeUpdate,
13922 ActorVnodeBitmapUpdate,
13923 DroppedActors,
13924 ActorSplits,
13925 ActorNewDispatchers,
13926 }
13927 impl<'de> serde::Deserialize<'de> for GeneratedField {
13928 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13929 where
13930 D: serde::Deserializer<'de>,
13931 {
13932 struct GeneratedVisitor;
13933
13934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13935 type Value = GeneratedField;
13936
13937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13938 write!(formatter, "expected one of: {:?}", &FIELDS)
13939 }
13940
13941 #[allow(unused_variables)]
13942 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13943 where
13944 E: serde::de::Error,
13945 {
13946 match value {
13947 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
13948 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
13949 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
13950 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
13951 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
13952 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
13953 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13954 }
13955 }
13956 }
13957 deserializer.deserialize_identifier(GeneratedVisitor)
13958 }
13959 }
13960 struct GeneratedVisitor;
13961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13962 type Value = UpdateMutation;
13963
13964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13965 formatter.write_str("struct stream_plan.UpdateMutation")
13966 }
13967
13968 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
13969 where
13970 V: serde::de::MapAccess<'de>,
13971 {
13972 let mut dispatcher_update__ = None;
13973 let mut merge_update__ = None;
13974 let mut actor_vnode_bitmap_update__ = None;
13975 let mut dropped_actors__ = None;
13976 let mut actor_splits__ = None;
13977 let mut actor_new_dispatchers__ = None;
13978 while let Some(k) = map_.next_key()? {
13979 match k {
13980 GeneratedField::DispatcherUpdate => {
13981 if dispatcher_update__.is_some() {
13982 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
13983 }
13984 dispatcher_update__ = Some(map_.next_value()?);
13985 }
13986 GeneratedField::MergeUpdate => {
13987 if merge_update__.is_some() {
13988 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
13989 }
13990 merge_update__ = Some(map_.next_value()?);
13991 }
13992 GeneratedField::ActorVnodeBitmapUpdate => {
13993 if actor_vnode_bitmap_update__.is_some() {
13994 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
13995 }
13996 actor_vnode_bitmap_update__ = Some(
13997 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13998 .into_iter().map(|(k,v)| (k.0, v)).collect()
13999 );
14000 }
14001 GeneratedField::DroppedActors => {
14002 if dropped_actors__.is_some() {
14003 return Err(serde::de::Error::duplicate_field("droppedActors"));
14004 }
14005 dropped_actors__ =
14006 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14007 .into_iter().map(|x| x.0).collect())
14008 ;
14009 }
14010 GeneratedField::ActorSplits => {
14011 if actor_splits__.is_some() {
14012 return Err(serde::de::Error::duplicate_field("actorSplits"));
14013 }
14014 actor_splits__ = Some(
14015 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14016 .into_iter().map(|(k,v)| (k.0, v)).collect()
14017 );
14018 }
14019 GeneratedField::ActorNewDispatchers => {
14020 if actor_new_dispatchers__.is_some() {
14021 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14022 }
14023 actor_new_dispatchers__ = Some(
14024 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14025 .into_iter().map(|(k,v)| (k.0, v)).collect()
14026 );
14027 }
14028 }
14029 }
14030 Ok(UpdateMutation {
14031 dispatcher_update: dispatcher_update__.unwrap_or_default(),
14032 merge_update: merge_update__.unwrap_or_default(),
14033 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
14034 dropped_actors: dropped_actors__.unwrap_or_default(),
14035 actor_splits: actor_splits__.unwrap_or_default(),
14036 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
14037 })
14038 }
14039 }
14040 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
14041 }
14042}
14043impl serde::Serialize for update_mutation::DispatcherUpdate {
14044 #[allow(deprecated)]
14045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14046 where
14047 S: serde::Serializer,
14048 {
14049 use serde::ser::SerializeStruct;
14050 let mut len = 0;
14051 if self.actor_id != 0 {
14052 len += 1;
14053 }
14054 if self.dispatcher_id != 0 {
14055 len += 1;
14056 }
14057 if self.hash_mapping.is_some() {
14058 len += 1;
14059 }
14060 if !self.added_downstream_actor_id.is_empty() {
14061 len += 1;
14062 }
14063 if !self.removed_downstream_actor_id.is_empty() {
14064 len += 1;
14065 }
14066 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
14067 if self.actor_id != 0 {
14068 struct_ser.serialize_field("actorId", &self.actor_id)?;
14069 }
14070 if self.dispatcher_id != 0 {
14071 #[allow(clippy::needless_borrow)]
14072 #[allow(clippy::needless_borrows_for_generic_args)]
14073 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
14074 }
14075 if let Some(v) = self.hash_mapping.as_ref() {
14076 struct_ser.serialize_field("hashMapping", v)?;
14077 }
14078 if !self.added_downstream_actor_id.is_empty() {
14079 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
14080 }
14081 if !self.removed_downstream_actor_id.is_empty() {
14082 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
14083 }
14084 struct_ser.end()
14085 }
14086}
14087impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
14088 #[allow(deprecated)]
14089 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14090 where
14091 D: serde::Deserializer<'de>,
14092 {
14093 const FIELDS: &[&str] = &[
14094 "actor_id",
14095 "actorId",
14096 "dispatcher_id",
14097 "dispatcherId",
14098 "hash_mapping",
14099 "hashMapping",
14100 "added_downstream_actor_id",
14101 "addedDownstreamActorId",
14102 "removed_downstream_actor_id",
14103 "removedDownstreamActorId",
14104 ];
14105
14106 #[allow(clippy::enum_variant_names)]
14107 enum GeneratedField {
14108 ActorId,
14109 DispatcherId,
14110 HashMapping,
14111 AddedDownstreamActorId,
14112 RemovedDownstreamActorId,
14113 }
14114 impl<'de> serde::Deserialize<'de> for GeneratedField {
14115 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14116 where
14117 D: serde::Deserializer<'de>,
14118 {
14119 struct GeneratedVisitor;
14120
14121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14122 type Value = GeneratedField;
14123
14124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14125 write!(formatter, "expected one of: {:?}", &FIELDS)
14126 }
14127
14128 #[allow(unused_variables)]
14129 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14130 where
14131 E: serde::de::Error,
14132 {
14133 match value {
14134 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14135 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
14136 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
14137 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
14138 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
14139 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14140 }
14141 }
14142 }
14143 deserializer.deserialize_identifier(GeneratedVisitor)
14144 }
14145 }
14146 struct GeneratedVisitor;
14147 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14148 type Value = update_mutation::DispatcherUpdate;
14149
14150 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14151 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
14152 }
14153
14154 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
14155 where
14156 V: serde::de::MapAccess<'de>,
14157 {
14158 let mut actor_id__ = None;
14159 let mut dispatcher_id__ = None;
14160 let mut hash_mapping__ = None;
14161 let mut added_downstream_actor_id__ = None;
14162 let mut removed_downstream_actor_id__ = None;
14163 while let Some(k) = map_.next_key()? {
14164 match k {
14165 GeneratedField::ActorId => {
14166 if actor_id__.is_some() {
14167 return Err(serde::de::Error::duplicate_field("actorId"));
14168 }
14169 actor_id__ =
14170 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14171 ;
14172 }
14173 GeneratedField::DispatcherId => {
14174 if dispatcher_id__.is_some() {
14175 return Err(serde::de::Error::duplicate_field("dispatcherId"));
14176 }
14177 dispatcher_id__ =
14178 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14179 ;
14180 }
14181 GeneratedField::HashMapping => {
14182 if hash_mapping__.is_some() {
14183 return Err(serde::de::Error::duplicate_field("hashMapping"));
14184 }
14185 hash_mapping__ = map_.next_value()?;
14186 }
14187 GeneratedField::AddedDownstreamActorId => {
14188 if added_downstream_actor_id__.is_some() {
14189 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
14190 }
14191 added_downstream_actor_id__ =
14192 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14193 .into_iter().map(|x| x.0).collect())
14194 ;
14195 }
14196 GeneratedField::RemovedDownstreamActorId => {
14197 if removed_downstream_actor_id__.is_some() {
14198 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
14199 }
14200 removed_downstream_actor_id__ =
14201 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14202 .into_iter().map(|x| x.0).collect())
14203 ;
14204 }
14205 }
14206 }
14207 Ok(update_mutation::DispatcherUpdate {
14208 actor_id: actor_id__.unwrap_or_default(),
14209 dispatcher_id: dispatcher_id__.unwrap_or_default(),
14210 hash_mapping: hash_mapping__,
14211 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
14212 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
14213 })
14214 }
14215 }
14216 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
14217 }
14218}
14219impl serde::Serialize for update_mutation::MergeUpdate {
14220 #[allow(deprecated)]
14221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14222 where
14223 S: serde::Serializer,
14224 {
14225 use serde::ser::SerializeStruct;
14226 let mut len = 0;
14227 if self.actor_id != 0 {
14228 len += 1;
14229 }
14230 if self.upstream_fragment_id != 0 {
14231 len += 1;
14232 }
14233 if self.new_upstream_fragment_id.is_some() {
14234 len += 1;
14235 }
14236 if !self.added_upstream_actors.is_empty() {
14237 len += 1;
14238 }
14239 if !self.removed_upstream_actor_id.is_empty() {
14240 len += 1;
14241 }
14242 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
14243 if self.actor_id != 0 {
14244 struct_ser.serialize_field("actorId", &self.actor_id)?;
14245 }
14246 if self.upstream_fragment_id != 0 {
14247 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
14248 }
14249 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
14250 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
14251 }
14252 if !self.added_upstream_actors.is_empty() {
14253 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
14254 }
14255 if !self.removed_upstream_actor_id.is_empty() {
14256 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
14257 }
14258 struct_ser.end()
14259 }
14260}
14261impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
14262 #[allow(deprecated)]
14263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14264 where
14265 D: serde::Deserializer<'de>,
14266 {
14267 const FIELDS: &[&str] = &[
14268 "actor_id",
14269 "actorId",
14270 "upstream_fragment_id",
14271 "upstreamFragmentId",
14272 "new_upstream_fragment_id",
14273 "newUpstreamFragmentId",
14274 "added_upstream_actors",
14275 "addedUpstreamActors",
14276 "removed_upstream_actor_id",
14277 "removedUpstreamActorId",
14278 ];
14279
14280 #[allow(clippy::enum_variant_names)]
14281 enum GeneratedField {
14282 ActorId,
14283 UpstreamFragmentId,
14284 NewUpstreamFragmentId,
14285 AddedUpstreamActors,
14286 RemovedUpstreamActorId,
14287 }
14288 impl<'de> serde::Deserialize<'de> for GeneratedField {
14289 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14290 where
14291 D: serde::Deserializer<'de>,
14292 {
14293 struct GeneratedVisitor;
14294
14295 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14296 type Value = GeneratedField;
14297
14298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14299 write!(formatter, "expected one of: {:?}", &FIELDS)
14300 }
14301
14302 #[allow(unused_variables)]
14303 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14304 where
14305 E: serde::de::Error,
14306 {
14307 match value {
14308 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14309 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
14310 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
14311 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
14312 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
14313 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14314 }
14315 }
14316 }
14317 deserializer.deserialize_identifier(GeneratedVisitor)
14318 }
14319 }
14320 struct GeneratedVisitor;
14321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14322 type Value = update_mutation::MergeUpdate;
14323
14324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14325 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
14326 }
14327
14328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
14329 where
14330 V: serde::de::MapAccess<'de>,
14331 {
14332 let mut actor_id__ = None;
14333 let mut upstream_fragment_id__ = None;
14334 let mut new_upstream_fragment_id__ = None;
14335 let mut added_upstream_actors__ = None;
14336 let mut removed_upstream_actor_id__ = None;
14337 while let Some(k) = map_.next_key()? {
14338 match k {
14339 GeneratedField::ActorId => {
14340 if actor_id__.is_some() {
14341 return Err(serde::de::Error::duplicate_field("actorId"));
14342 }
14343 actor_id__ =
14344 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14345 ;
14346 }
14347 GeneratedField::UpstreamFragmentId => {
14348 if upstream_fragment_id__.is_some() {
14349 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
14350 }
14351 upstream_fragment_id__ =
14352 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14353 ;
14354 }
14355 GeneratedField::NewUpstreamFragmentId => {
14356 if new_upstream_fragment_id__.is_some() {
14357 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
14358 }
14359 new_upstream_fragment_id__ =
14360 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14361 ;
14362 }
14363 GeneratedField::AddedUpstreamActors => {
14364 if added_upstream_actors__.is_some() {
14365 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
14366 }
14367 added_upstream_actors__ = Some(map_.next_value()?);
14368 }
14369 GeneratedField::RemovedUpstreamActorId => {
14370 if removed_upstream_actor_id__.is_some() {
14371 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
14372 }
14373 removed_upstream_actor_id__ =
14374 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14375 .into_iter().map(|x| x.0).collect())
14376 ;
14377 }
14378 }
14379 }
14380 Ok(update_mutation::MergeUpdate {
14381 actor_id: actor_id__.unwrap_or_default(),
14382 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
14383 new_upstream_fragment_id: new_upstream_fragment_id__,
14384 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
14385 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
14386 })
14387 }
14388 }
14389 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
14390 }
14391}
14392impl serde::Serialize for ValuesNode {
14393 #[allow(deprecated)]
14394 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14395 where
14396 S: serde::Serializer,
14397 {
14398 use serde::ser::SerializeStruct;
14399 let mut len = 0;
14400 if !self.tuples.is_empty() {
14401 len += 1;
14402 }
14403 if !self.fields.is_empty() {
14404 len += 1;
14405 }
14406 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
14407 if !self.tuples.is_empty() {
14408 struct_ser.serialize_field("tuples", &self.tuples)?;
14409 }
14410 if !self.fields.is_empty() {
14411 struct_ser.serialize_field("fields", &self.fields)?;
14412 }
14413 struct_ser.end()
14414 }
14415}
14416impl<'de> serde::Deserialize<'de> for ValuesNode {
14417 #[allow(deprecated)]
14418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14419 where
14420 D: serde::Deserializer<'de>,
14421 {
14422 const FIELDS: &[&str] = &[
14423 "tuples",
14424 "fields",
14425 ];
14426
14427 #[allow(clippy::enum_variant_names)]
14428 enum GeneratedField {
14429 Tuples,
14430 Fields,
14431 }
14432 impl<'de> serde::Deserialize<'de> for GeneratedField {
14433 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14434 where
14435 D: serde::Deserializer<'de>,
14436 {
14437 struct GeneratedVisitor;
14438
14439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14440 type Value = GeneratedField;
14441
14442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14443 write!(formatter, "expected one of: {:?}", &FIELDS)
14444 }
14445
14446 #[allow(unused_variables)]
14447 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14448 where
14449 E: serde::de::Error,
14450 {
14451 match value {
14452 "tuples" => Ok(GeneratedField::Tuples),
14453 "fields" => Ok(GeneratedField::Fields),
14454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14455 }
14456 }
14457 }
14458 deserializer.deserialize_identifier(GeneratedVisitor)
14459 }
14460 }
14461 struct GeneratedVisitor;
14462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14463 type Value = ValuesNode;
14464
14465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14466 formatter.write_str("struct stream_plan.ValuesNode")
14467 }
14468
14469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
14470 where
14471 V: serde::de::MapAccess<'de>,
14472 {
14473 let mut tuples__ = None;
14474 let mut fields__ = None;
14475 while let Some(k) = map_.next_key()? {
14476 match k {
14477 GeneratedField::Tuples => {
14478 if tuples__.is_some() {
14479 return Err(serde::de::Error::duplicate_field("tuples"));
14480 }
14481 tuples__ = Some(map_.next_value()?);
14482 }
14483 GeneratedField::Fields => {
14484 if fields__.is_some() {
14485 return Err(serde::de::Error::duplicate_field("fields"));
14486 }
14487 fields__ = Some(map_.next_value()?);
14488 }
14489 }
14490 }
14491 Ok(ValuesNode {
14492 tuples: tuples__.unwrap_or_default(),
14493 fields: fields__.unwrap_or_default(),
14494 })
14495 }
14496 }
14497 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
14498 }
14499}
14500impl serde::Serialize for values_node::ExprTuple {
14501 #[allow(deprecated)]
14502 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14503 where
14504 S: serde::Serializer,
14505 {
14506 use serde::ser::SerializeStruct;
14507 let mut len = 0;
14508 if !self.cells.is_empty() {
14509 len += 1;
14510 }
14511 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
14512 if !self.cells.is_empty() {
14513 struct_ser.serialize_field("cells", &self.cells)?;
14514 }
14515 struct_ser.end()
14516 }
14517}
14518impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
14519 #[allow(deprecated)]
14520 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14521 where
14522 D: serde::Deserializer<'de>,
14523 {
14524 const FIELDS: &[&str] = &[
14525 "cells",
14526 ];
14527
14528 #[allow(clippy::enum_variant_names)]
14529 enum GeneratedField {
14530 Cells,
14531 }
14532 impl<'de> serde::Deserialize<'de> for GeneratedField {
14533 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14534 where
14535 D: serde::Deserializer<'de>,
14536 {
14537 struct GeneratedVisitor;
14538
14539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14540 type Value = GeneratedField;
14541
14542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14543 write!(formatter, "expected one of: {:?}", &FIELDS)
14544 }
14545
14546 #[allow(unused_variables)]
14547 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14548 where
14549 E: serde::de::Error,
14550 {
14551 match value {
14552 "cells" => Ok(GeneratedField::Cells),
14553 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14554 }
14555 }
14556 }
14557 deserializer.deserialize_identifier(GeneratedVisitor)
14558 }
14559 }
14560 struct GeneratedVisitor;
14561 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14562 type Value = values_node::ExprTuple;
14563
14564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14565 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
14566 }
14567
14568 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
14569 where
14570 V: serde::de::MapAccess<'de>,
14571 {
14572 let mut cells__ = None;
14573 while let Some(k) = map_.next_key()? {
14574 match k {
14575 GeneratedField::Cells => {
14576 if cells__.is_some() {
14577 return Err(serde::de::Error::duplicate_field("cells"));
14578 }
14579 cells__ = Some(map_.next_value()?);
14580 }
14581 }
14582 }
14583 Ok(values_node::ExprTuple {
14584 cells: cells__.unwrap_or_default(),
14585 })
14586 }
14587 }
14588 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
14589 }
14590}
14591impl serde::Serialize for Watermark {
14592 #[allow(deprecated)]
14593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14594 where
14595 S: serde::Serializer,
14596 {
14597 use serde::ser::SerializeStruct;
14598 let mut len = 0;
14599 if self.column.is_some() {
14600 len += 1;
14601 }
14602 if self.val.is_some() {
14603 len += 1;
14604 }
14605 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
14606 if let Some(v) = self.column.as_ref() {
14607 struct_ser.serialize_field("column", v)?;
14608 }
14609 if let Some(v) = self.val.as_ref() {
14610 struct_ser.serialize_field("val", v)?;
14611 }
14612 struct_ser.end()
14613 }
14614}
14615impl<'de> serde::Deserialize<'de> for Watermark {
14616 #[allow(deprecated)]
14617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14618 where
14619 D: serde::Deserializer<'de>,
14620 {
14621 const FIELDS: &[&str] = &[
14622 "column",
14623 "val",
14624 ];
14625
14626 #[allow(clippy::enum_variant_names)]
14627 enum GeneratedField {
14628 Column,
14629 Val,
14630 }
14631 impl<'de> serde::Deserialize<'de> for GeneratedField {
14632 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14633 where
14634 D: serde::Deserializer<'de>,
14635 {
14636 struct GeneratedVisitor;
14637
14638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14639 type Value = GeneratedField;
14640
14641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14642 write!(formatter, "expected one of: {:?}", &FIELDS)
14643 }
14644
14645 #[allow(unused_variables)]
14646 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14647 where
14648 E: serde::de::Error,
14649 {
14650 match value {
14651 "column" => Ok(GeneratedField::Column),
14652 "val" => Ok(GeneratedField::Val),
14653 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14654 }
14655 }
14656 }
14657 deserializer.deserialize_identifier(GeneratedVisitor)
14658 }
14659 }
14660 struct GeneratedVisitor;
14661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14662 type Value = Watermark;
14663
14664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14665 formatter.write_str("struct stream_plan.Watermark")
14666 }
14667
14668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
14669 where
14670 V: serde::de::MapAccess<'de>,
14671 {
14672 let mut column__ = None;
14673 let mut val__ = None;
14674 while let Some(k) = map_.next_key()? {
14675 match k {
14676 GeneratedField::Column => {
14677 if column__.is_some() {
14678 return Err(serde::de::Error::duplicate_field("column"));
14679 }
14680 column__ = map_.next_value()?;
14681 }
14682 GeneratedField::Val => {
14683 if val__.is_some() {
14684 return Err(serde::de::Error::duplicate_field("val"));
14685 }
14686 val__ = map_.next_value()?;
14687 }
14688 }
14689 }
14690 Ok(Watermark {
14691 column: column__,
14692 val: val__,
14693 })
14694 }
14695 }
14696 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
14697 }
14698}
14699impl serde::Serialize for WatermarkFilterNode {
14700 #[allow(deprecated)]
14701 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14702 where
14703 S: serde::Serializer,
14704 {
14705 use serde::ser::SerializeStruct;
14706 let mut len = 0;
14707 if !self.watermark_descs.is_empty() {
14708 len += 1;
14709 }
14710 if !self.tables.is_empty() {
14711 len += 1;
14712 }
14713 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
14714 if !self.watermark_descs.is_empty() {
14715 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
14716 }
14717 if !self.tables.is_empty() {
14718 struct_ser.serialize_field("tables", &self.tables)?;
14719 }
14720 struct_ser.end()
14721 }
14722}
14723impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
14724 #[allow(deprecated)]
14725 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14726 where
14727 D: serde::Deserializer<'de>,
14728 {
14729 const FIELDS: &[&str] = &[
14730 "watermark_descs",
14731 "watermarkDescs",
14732 "tables",
14733 ];
14734
14735 #[allow(clippy::enum_variant_names)]
14736 enum GeneratedField {
14737 WatermarkDescs,
14738 Tables,
14739 }
14740 impl<'de> serde::Deserialize<'de> for GeneratedField {
14741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14742 where
14743 D: serde::Deserializer<'de>,
14744 {
14745 struct GeneratedVisitor;
14746
14747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14748 type Value = GeneratedField;
14749
14750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14751 write!(formatter, "expected one of: {:?}", &FIELDS)
14752 }
14753
14754 #[allow(unused_variables)]
14755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14756 where
14757 E: serde::de::Error,
14758 {
14759 match value {
14760 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
14761 "tables" => Ok(GeneratedField::Tables),
14762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14763 }
14764 }
14765 }
14766 deserializer.deserialize_identifier(GeneratedVisitor)
14767 }
14768 }
14769 struct GeneratedVisitor;
14770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14771 type Value = WatermarkFilterNode;
14772
14773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14774 formatter.write_str("struct stream_plan.WatermarkFilterNode")
14775 }
14776
14777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
14778 where
14779 V: serde::de::MapAccess<'de>,
14780 {
14781 let mut watermark_descs__ = None;
14782 let mut tables__ = None;
14783 while let Some(k) = map_.next_key()? {
14784 match k {
14785 GeneratedField::WatermarkDescs => {
14786 if watermark_descs__.is_some() {
14787 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
14788 }
14789 watermark_descs__ = Some(map_.next_value()?);
14790 }
14791 GeneratedField::Tables => {
14792 if tables__.is_some() {
14793 return Err(serde::de::Error::duplicate_field("tables"));
14794 }
14795 tables__ = Some(map_.next_value()?);
14796 }
14797 }
14798 }
14799 Ok(WatermarkFilterNode {
14800 watermark_descs: watermark_descs__.unwrap_or_default(),
14801 tables: tables__.unwrap_or_default(),
14802 })
14803 }
14804 }
14805 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
14806 }
14807}