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 DispatchOutputMapping {
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.indices.is_empty() {
2986 len += 1;
2987 }
2988 if !self.types.is_empty() {
2989 len += 1;
2990 }
2991 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
2992 if !self.indices.is_empty() {
2993 struct_ser.serialize_field("indices", &self.indices)?;
2994 }
2995 if !self.types.is_empty() {
2996 struct_ser.serialize_field("types", &self.types)?;
2997 }
2998 struct_ser.end()
2999 }
3000}
3001impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3002 #[allow(deprecated)]
3003 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3004 where
3005 D: serde::Deserializer<'de>,
3006 {
3007 const FIELDS: &[&str] = &[
3008 "indices",
3009 "types",
3010 ];
3011
3012 #[allow(clippy::enum_variant_names)]
3013 enum GeneratedField {
3014 Indices,
3015 Types,
3016 }
3017 impl<'de> serde::Deserialize<'de> for GeneratedField {
3018 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3019 where
3020 D: serde::Deserializer<'de>,
3021 {
3022 struct GeneratedVisitor;
3023
3024 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3025 type Value = GeneratedField;
3026
3027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3028 write!(formatter, "expected one of: {:?}", &FIELDS)
3029 }
3030
3031 #[allow(unused_variables)]
3032 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3033 where
3034 E: serde::de::Error,
3035 {
3036 match value {
3037 "indices" => Ok(GeneratedField::Indices),
3038 "types" => Ok(GeneratedField::Types),
3039 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3040 }
3041 }
3042 }
3043 deserializer.deserialize_identifier(GeneratedVisitor)
3044 }
3045 }
3046 struct GeneratedVisitor;
3047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3048 type Value = DispatchOutputMapping;
3049
3050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3051 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3052 }
3053
3054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3055 where
3056 V: serde::de::MapAccess<'de>,
3057 {
3058 let mut indices__ = None;
3059 let mut types__ = None;
3060 while let Some(k) = map_.next_key()? {
3061 match k {
3062 GeneratedField::Indices => {
3063 if indices__.is_some() {
3064 return Err(serde::de::Error::duplicate_field("indices"));
3065 }
3066 indices__ =
3067 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3068 .into_iter().map(|x| x.0).collect())
3069 ;
3070 }
3071 GeneratedField::Types => {
3072 if types__.is_some() {
3073 return Err(serde::de::Error::duplicate_field("types"));
3074 }
3075 types__ = Some(map_.next_value()?);
3076 }
3077 }
3078 }
3079 Ok(DispatchOutputMapping {
3080 indices: indices__.unwrap_or_default(),
3081 types: types__.unwrap_or_default(),
3082 })
3083 }
3084 }
3085 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3086 }
3087}
3088impl serde::Serialize for dispatch_output_mapping::TypePair {
3089 #[allow(deprecated)]
3090 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3091 where
3092 S: serde::Serializer,
3093 {
3094 use serde::ser::SerializeStruct;
3095 let mut len = 0;
3096 if self.upstream.is_some() {
3097 len += 1;
3098 }
3099 if self.downstream.is_some() {
3100 len += 1;
3101 }
3102 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3103 if let Some(v) = self.upstream.as_ref() {
3104 struct_ser.serialize_field("upstream", v)?;
3105 }
3106 if let Some(v) = self.downstream.as_ref() {
3107 struct_ser.serialize_field("downstream", v)?;
3108 }
3109 struct_ser.end()
3110 }
3111}
3112impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3113 #[allow(deprecated)]
3114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3115 where
3116 D: serde::Deserializer<'de>,
3117 {
3118 const FIELDS: &[&str] = &[
3119 "upstream",
3120 "downstream",
3121 ];
3122
3123 #[allow(clippy::enum_variant_names)]
3124 enum GeneratedField {
3125 Upstream,
3126 Downstream,
3127 }
3128 impl<'de> serde::Deserialize<'de> for GeneratedField {
3129 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3130 where
3131 D: serde::Deserializer<'de>,
3132 {
3133 struct GeneratedVisitor;
3134
3135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3136 type Value = GeneratedField;
3137
3138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3139 write!(formatter, "expected one of: {:?}", &FIELDS)
3140 }
3141
3142 #[allow(unused_variables)]
3143 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3144 where
3145 E: serde::de::Error,
3146 {
3147 match value {
3148 "upstream" => Ok(GeneratedField::Upstream),
3149 "downstream" => Ok(GeneratedField::Downstream),
3150 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3151 }
3152 }
3153 }
3154 deserializer.deserialize_identifier(GeneratedVisitor)
3155 }
3156 }
3157 struct GeneratedVisitor;
3158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3159 type Value = dispatch_output_mapping::TypePair;
3160
3161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3162 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3163 }
3164
3165 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3166 where
3167 V: serde::de::MapAccess<'de>,
3168 {
3169 let mut upstream__ = None;
3170 let mut downstream__ = None;
3171 while let Some(k) = map_.next_key()? {
3172 match k {
3173 GeneratedField::Upstream => {
3174 if upstream__.is_some() {
3175 return Err(serde::de::Error::duplicate_field("upstream"));
3176 }
3177 upstream__ = map_.next_value()?;
3178 }
3179 GeneratedField::Downstream => {
3180 if downstream__.is_some() {
3181 return Err(serde::de::Error::duplicate_field("downstream"));
3182 }
3183 downstream__ = map_.next_value()?;
3184 }
3185 }
3186 }
3187 Ok(dispatch_output_mapping::TypePair {
3188 upstream: upstream__,
3189 downstream: downstream__,
3190 })
3191 }
3192 }
3193 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3194 }
3195}
3196impl serde::Serialize for DispatchStrategy {
3197 #[allow(deprecated)]
3198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3199 where
3200 S: serde::Serializer,
3201 {
3202 use serde::ser::SerializeStruct;
3203 let mut len = 0;
3204 if self.r#type != 0 {
3205 len += 1;
3206 }
3207 if !self.dist_key_indices.is_empty() {
3208 len += 1;
3209 }
3210 if self.output_mapping.is_some() {
3211 len += 1;
3212 }
3213 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3214 if self.r#type != 0 {
3215 let v = DispatcherType::try_from(self.r#type)
3216 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3217 struct_ser.serialize_field("type", &v)?;
3218 }
3219 if !self.dist_key_indices.is_empty() {
3220 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3221 }
3222 if let Some(v) = self.output_mapping.as_ref() {
3223 struct_ser.serialize_field("outputMapping", v)?;
3224 }
3225 struct_ser.end()
3226 }
3227}
3228impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3229 #[allow(deprecated)]
3230 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3231 where
3232 D: serde::Deserializer<'de>,
3233 {
3234 const FIELDS: &[&str] = &[
3235 "type",
3236 "dist_key_indices",
3237 "distKeyIndices",
3238 "output_mapping",
3239 "outputMapping",
3240 ];
3241
3242 #[allow(clippy::enum_variant_names)]
3243 enum GeneratedField {
3244 Type,
3245 DistKeyIndices,
3246 OutputMapping,
3247 }
3248 impl<'de> serde::Deserialize<'de> for GeneratedField {
3249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3250 where
3251 D: serde::Deserializer<'de>,
3252 {
3253 struct GeneratedVisitor;
3254
3255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3256 type Value = GeneratedField;
3257
3258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3259 write!(formatter, "expected one of: {:?}", &FIELDS)
3260 }
3261
3262 #[allow(unused_variables)]
3263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3264 where
3265 E: serde::de::Error,
3266 {
3267 match value {
3268 "type" => Ok(GeneratedField::Type),
3269 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3270 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3271 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3272 }
3273 }
3274 }
3275 deserializer.deserialize_identifier(GeneratedVisitor)
3276 }
3277 }
3278 struct GeneratedVisitor;
3279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3280 type Value = DispatchStrategy;
3281
3282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3283 formatter.write_str("struct stream_plan.DispatchStrategy")
3284 }
3285
3286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3287 where
3288 V: serde::de::MapAccess<'de>,
3289 {
3290 let mut r#type__ = None;
3291 let mut dist_key_indices__ = None;
3292 let mut output_mapping__ = None;
3293 while let Some(k) = map_.next_key()? {
3294 match k {
3295 GeneratedField::Type => {
3296 if r#type__.is_some() {
3297 return Err(serde::de::Error::duplicate_field("type"));
3298 }
3299 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3300 }
3301 GeneratedField::DistKeyIndices => {
3302 if dist_key_indices__.is_some() {
3303 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3304 }
3305 dist_key_indices__ =
3306 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3307 .into_iter().map(|x| x.0).collect())
3308 ;
3309 }
3310 GeneratedField::OutputMapping => {
3311 if output_mapping__.is_some() {
3312 return Err(serde::de::Error::duplicate_field("outputMapping"));
3313 }
3314 output_mapping__ = map_.next_value()?;
3315 }
3316 }
3317 }
3318 Ok(DispatchStrategy {
3319 r#type: r#type__.unwrap_or_default(),
3320 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3321 output_mapping: output_mapping__,
3322 })
3323 }
3324 }
3325 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3326 }
3327}
3328impl serde::Serialize for Dispatcher {
3329 #[allow(deprecated)]
3330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3331 where
3332 S: serde::Serializer,
3333 {
3334 use serde::ser::SerializeStruct;
3335 let mut len = 0;
3336 if self.r#type != 0 {
3337 len += 1;
3338 }
3339 if !self.dist_key_indices.is_empty() {
3340 len += 1;
3341 }
3342 if self.output_mapping.is_some() {
3343 len += 1;
3344 }
3345 if self.hash_mapping.is_some() {
3346 len += 1;
3347 }
3348 if self.dispatcher_id != 0 {
3349 len += 1;
3350 }
3351 if !self.downstream_actor_id.is_empty() {
3352 len += 1;
3353 }
3354 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3355 if self.r#type != 0 {
3356 let v = DispatcherType::try_from(self.r#type)
3357 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3358 struct_ser.serialize_field("type", &v)?;
3359 }
3360 if !self.dist_key_indices.is_empty() {
3361 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3362 }
3363 if let Some(v) = self.output_mapping.as_ref() {
3364 struct_ser.serialize_field("outputMapping", v)?;
3365 }
3366 if let Some(v) = self.hash_mapping.as_ref() {
3367 struct_ser.serialize_field("hashMapping", v)?;
3368 }
3369 if self.dispatcher_id != 0 {
3370 #[allow(clippy::needless_borrow)]
3371 #[allow(clippy::needless_borrows_for_generic_args)]
3372 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3373 }
3374 if !self.downstream_actor_id.is_empty() {
3375 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3376 }
3377 struct_ser.end()
3378 }
3379}
3380impl<'de> serde::Deserialize<'de> for Dispatcher {
3381 #[allow(deprecated)]
3382 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3383 where
3384 D: serde::Deserializer<'de>,
3385 {
3386 const FIELDS: &[&str] = &[
3387 "type",
3388 "dist_key_indices",
3389 "distKeyIndices",
3390 "output_mapping",
3391 "outputMapping",
3392 "hash_mapping",
3393 "hashMapping",
3394 "dispatcher_id",
3395 "dispatcherId",
3396 "downstream_actor_id",
3397 "downstreamActorId",
3398 ];
3399
3400 #[allow(clippy::enum_variant_names)]
3401 enum GeneratedField {
3402 Type,
3403 DistKeyIndices,
3404 OutputMapping,
3405 HashMapping,
3406 DispatcherId,
3407 DownstreamActorId,
3408 }
3409 impl<'de> serde::Deserialize<'de> for GeneratedField {
3410 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3411 where
3412 D: serde::Deserializer<'de>,
3413 {
3414 struct GeneratedVisitor;
3415
3416 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3417 type Value = GeneratedField;
3418
3419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3420 write!(formatter, "expected one of: {:?}", &FIELDS)
3421 }
3422
3423 #[allow(unused_variables)]
3424 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3425 where
3426 E: serde::de::Error,
3427 {
3428 match value {
3429 "type" => Ok(GeneratedField::Type),
3430 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3431 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3432 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3433 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3434 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3435 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3436 }
3437 }
3438 }
3439 deserializer.deserialize_identifier(GeneratedVisitor)
3440 }
3441 }
3442 struct GeneratedVisitor;
3443 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3444 type Value = Dispatcher;
3445
3446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3447 formatter.write_str("struct stream_plan.Dispatcher")
3448 }
3449
3450 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3451 where
3452 V: serde::de::MapAccess<'de>,
3453 {
3454 let mut r#type__ = None;
3455 let mut dist_key_indices__ = None;
3456 let mut output_mapping__ = None;
3457 let mut hash_mapping__ = None;
3458 let mut dispatcher_id__ = None;
3459 let mut downstream_actor_id__ = None;
3460 while let Some(k) = map_.next_key()? {
3461 match k {
3462 GeneratedField::Type => {
3463 if r#type__.is_some() {
3464 return Err(serde::de::Error::duplicate_field("type"));
3465 }
3466 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3467 }
3468 GeneratedField::DistKeyIndices => {
3469 if dist_key_indices__.is_some() {
3470 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3471 }
3472 dist_key_indices__ =
3473 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3474 .into_iter().map(|x| x.0).collect())
3475 ;
3476 }
3477 GeneratedField::OutputMapping => {
3478 if output_mapping__.is_some() {
3479 return Err(serde::de::Error::duplicate_field("outputMapping"));
3480 }
3481 output_mapping__ = map_.next_value()?;
3482 }
3483 GeneratedField::HashMapping => {
3484 if hash_mapping__.is_some() {
3485 return Err(serde::de::Error::duplicate_field("hashMapping"));
3486 }
3487 hash_mapping__ = map_.next_value()?;
3488 }
3489 GeneratedField::DispatcherId => {
3490 if dispatcher_id__.is_some() {
3491 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3492 }
3493 dispatcher_id__ =
3494 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3495 ;
3496 }
3497 GeneratedField::DownstreamActorId => {
3498 if downstream_actor_id__.is_some() {
3499 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3500 }
3501 downstream_actor_id__ =
3502 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3503 .into_iter().map(|x| x.0).collect())
3504 ;
3505 }
3506 }
3507 }
3508 Ok(Dispatcher {
3509 r#type: r#type__.unwrap_or_default(),
3510 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3511 output_mapping: output_mapping__,
3512 hash_mapping: hash_mapping__,
3513 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3514 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3515 })
3516 }
3517 }
3518 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3519 }
3520}
3521impl serde::Serialize for DispatcherType {
3522 #[allow(deprecated)]
3523 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3524 where
3525 S: serde::Serializer,
3526 {
3527 let variant = match self {
3528 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3529 Self::Hash => "DISPATCHER_TYPE_HASH",
3530 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3531 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3532 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3533 };
3534 serializer.serialize_str(variant)
3535 }
3536}
3537impl<'de> serde::Deserialize<'de> for DispatcherType {
3538 #[allow(deprecated)]
3539 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3540 where
3541 D: serde::Deserializer<'de>,
3542 {
3543 const FIELDS: &[&str] = &[
3544 "DISPATCHER_TYPE_UNSPECIFIED",
3545 "DISPATCHER_TYPE_HASH",
3546 "DISPATCHER_TYPE_BROADCAST",
3547 "DISPATCHER_TYPE_SIMPLE",
3548 "DISPATCHER_TYPE_NO_SHUFFLE",
3549 ];
3550
3551 struct GeneratedVisitor;
3552
3553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3554 type Value = DispatcherType;
3555
3556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3557 write!(formatter, "expected one of: {:?}", &FIELDS)
3558 }
3559
3560 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3561 where
3562 E: serde::de::Error,
3563 {
3564 i32::try_from(v)
3565 .ok()
3566 .and_then(|x| x.try_into().ok())
3567 .ok_or_else(|| {
3568 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3569 })
3570 }
3571
3572 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3573 where
3574 E: serde::de::Error,
3575 {
3576 i32::try_from(v)
3577 .ok()
3578 .and_then(|x| x.try_into().ok())
3579 .ok_or_else(|| {
3580 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3581 })
3582 }
3583
3584 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3585 where
3586 E: serde::de::Error,
3587 {
3588 match value {
3589 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3590 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3591 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3592 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3593 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3594 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3595 }
3596 }
3597 }
3598 deserializer.deserialize_any(GeneratedVisitor)
3599 }
3600}
3601impl serde::Serialize for Dispatchers {
3602 #[allow(deprecated)]
3603 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3604 where
3605 S: serde::Serializer,
3606 {
3607 use serde::ser::SerializeStruct;
3608 let mut len = 0;
3609 if !self.dispatchers.is_empty() {
3610 len += 1;
3611 }
3612 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3613 if !self.dispatchers.is_empty() {
3614 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3615 }
3616 struct_ser.end()
3617 }
3618}
3619impl<'de> serde::Deserialize<'de> for Dispatchers {
3620 #[allow(deprecated)]
3621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3622 where
3623 D: serde::Deserializer<'de>,
3624 {
3625 const FIELDS: &[&str] = &[
3626 "dispatchers",
3627 ];
3628
3629 #[allow(clippy::enum_variant_names)]
3630 enum GeneratedField {
3631 Dispatchers,
3632 }
3633 impl<'de> serde::Deserialize<'de> for GeneratedField {
3634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3635 where
3636 D: serde::Deserializer<'de>,
3637 {
3638 struct GeneratedVisitor;
3639
3640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3641 type Value = GeneratedField;
3642
3643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3644 write!(formatter, "expected one of: {:?}", &FIELDS)
3645 }
3646
3647 #[allow(unused_variables)]
3648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3649 where
3650 E: serde::de::Error,
3651 {
3652 match value {
3653 "dispatchers" => Ok(GeneratedField::Dispatchers),
3654 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3655 }
3656 }
3657 }
3658 deserializer.deserialize_identifier(GeneratedVisitor)
3659 }
3660 }
3661 struct GeneratedVisitor;
3662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3663 type Value = Dispatchers;
3664
3665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3666 formatter.write_str("struct stream_plan.Dispatchers")
3667 }
3668
3669 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3670 where
3671 V: serde::de::MapAccess<'de>,
3672 {
3673 let mut dispatchers__ = None;
3674 while let Some(k) = map_.next_key()? {
3675 match k {
3676 GeneratedField::Dispatchers => {
3677 if dispatchers__.is_some() {
3678 return Err(serde::de::Error::duplicate_field("dispatchers"));
3679 }
3680 dispatchers__ = Some(map_.next_value()?);
3681 }
3682 }
3683 }
3684 Ok(Dispatchers {
3685 dispatchers: dispatchers__.unwrap_or_default(),
3686 })
3687 }
3688 }
3689 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3690 }
3691}
3692impl serde::Serialize for DmlNode {
3693 #[allow(deprecated)]
3694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3695 where
3696 S: serde::Serializer,
3697 {
3698 use serde::ser::SerializeStruct;
3699 let mut len = 0;
3700 if self.table_id != 0 {
3701 len += 1;
3702 }
3703 if self.table_version_id != 0 {
3704 len += 1;
3705 }
3706 if !self.column_descs.is_empty() {
3707 len += 1;
3708 }
3709 if self.rate_limit.is_some() {
3710 len += 1;
3711 }
3712 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3713 if self.table_id != 0 {
3714 struct_ser.serialize_field("tableId", &self.table_id)?;
3715 }
3716 if self.table_version_id != 0 {
3717 #[allow(clippy::needless_borrow)]
3718 #[allow(clippy::needless_borrows_for_generic_args)]
3719 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3720 }
3721 if !self.column_descs.is_empty() {
3722 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3723 }
3724 if let Some(v) = self.rate_limit.as_ref() {
3725 struct_ser.serialize_field("rateLimit", v)?;
3726 }
3727 struct_ser.end()
3728 }
3729}
3730impl<'de> serde::Deserialize<'de> for DmlNode {
3731 #[allow(deprecated)]
3732 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3733 where
3734 D: serde::Deserializer<'de>,
3735 {
3736 const FIELDS: &[&str] = &[
3737 "table_id",
3738 "tableId",
3739 "table_version_id",
3740 "tableVersionId",
3741 "column_descs",
3742 "columnDescs",
3743 "rate_limit",
3744 "rateLimit",
3745 ];
3746
3747 #[allow(clippy::enum_variant_names)]
3748 enum GeneratedField {
3749 TableId,
3750 TableVersionId,
3751 ColumnDescs,
3752 RateLimit,
3753 }
3754 impl<'de> serde::Deserialize<'de> for GeneratedField {
3755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3756 where
3757 D: serde::Deserializer<'de>,
3758 {
3759 struct GeneratedVisitor;
3760
3761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3762 type Value = GeneratedField;
3763
3764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3765 write!(formatter, "expected one of: {:?}", &FIELDS)
3766 }
3767
3768 #[allow(unused_variables)]
3769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3770 where
3771 E: serde::de::Error,
3772 {
3773 match value {
3774 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3775 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3776 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3777 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3779 }
3780 }
3781 }
3782 deserializer.deserialize_identifier(GeneratedVisitor)
3783 }
3784 }
3785 struct GeneratedVisitor;
3786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3787 type Value = DmlNode;
3788
3789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3790 formatter.write_str("struct stream_plan.DmlNode")
3791 }
3792
3793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
3794 where
3795 V: serde::de::MapAccess<'de>,
3796 {
3797 let mut table_id__ = None;
3798 let mut table_version_id__ = None;
3799 let mut column_descs__ = None;
3800 let mut rate_limit__ = None;
3801 while let Some(k) = map_.next_key()? {
3802 match k {
3803 GeneratedField::TableId => {
3804 if table_id__.is_some() {
3805 return Err(serde::de::Error::duplicate_field("tableId"));
3806 }
3807 table_id__ =
3808 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3809 ;
3810 }
3811 GeneratedField::TableVersionId => {
3812 if table_version_id__.is_some() {
3813 return Err(serde::de::Error::duplicate_field("tableVersionId"));
3814 }
3815 table_version_id__ =
3816 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3817 ;
3818 }
3819 GeneratedField::ColumnDescs => {
3820 if column_descs__.is_some() {
3821 return Err(serde::de::Error::duplicate_field("columnDescs"));
3822 }
3823 column_descs__ = Some(map_.next_value()?);
3824 }
3825 GeneratedField::RateLimit => {
3826 if rate_limit__.is_some() {
3827 return Err(serde::de::Error::duplicate_field("rateLimit"));
3828 }
3829 rate_limit__ =
3830 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3831 ;
3832 }
3833 }
3834 }
3835 Ok(DmlNode {
3836 table_id: table_id__.unwrap_or_default(),
3837 table_version_id: table_version_id__.unwrap_or_default(),
3838 column_descs: column_descs__.unwrap_or_default(),
3839 rate_limit: rate_limit__,
3840 })
3841 }
3842 }
3843 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
3844 }
3845}
3846impl serde::Serialize for DropSubscriptionsMutation {
3847 #[allow(deprecated)]
3848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3849 where
3850 S: serde::Serializer,
3851 {
3852 use serde::ser::SerializeStruct;
3853 let mut len = 0;
3854 if !self.info.is_empty() {
3855 len += 1;
3856 }
3857 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
3858 if !self.info.is_empty() {
3859 struct_ser.serialize_field("info", &self.info)?;
3860 }
3861 struct_ser.end()
3862 }
3863}
3864impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
3865 #[allow(deprecated)]
3866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3867 where
3868 D: serde::Deserializer<'de>,
3869 {
3870 const FIELDS: &[&str] = &[
3871 "info",
3872 ];
3873
3874 #[allow(clippy::enum_variant_names)]
3875 enum GeneratedField {
3876 Info,
3877 }
3878 impl<'de> serde::Deserialize<'de> for GeneratedField {
3879 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3880 where
3881 D: serde::Deserializer<'de>,
3882 {
3883 struct GeneratedVisitor;
3884
3885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3886 type Value = GeneratedField;
3887
3888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3889 write!(formatter, "expected one of: {:?}", &FIELDS)
3890 }
3891
3892 #[allow(unused_variables)]
3893 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3894 where
3895 E: serde::de::Error,
3896 {
3897 match value {
3898 "info" => Ok(GeneratedField::Info),
3899 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3900 }
3901 }
3902 }
3903 deserializer.deserialize_identifier(GeneratedVisitor)
3904 }
3905 }
3906 struct GeneratedVisitor;
3907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3908 type Value = DropSubscriptionsMutation;
3909
3910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3911 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
3912 }
3913
3914 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
3915 where
3916 V: serde::de::MapAccess<'de>,
3917 {
3918 let mut info__ = None;
3919 while let Some(k) = map_.next_key()? {
3920 match k {
3921 GeneratedField::Info => {
3922 if info__.is_some() {
3923 return Err(serde::de::Error::duplicate_field("info"));
3924 }
3925 info__ = Some(map_.next_value()?);
3926 }
3927 }
3928 }
3929 Ok(DropSubscriptionsMutation {
3930 info: info__.unwrap_or_default(),
3931 })
3932 }
3933 }
3934 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
3935 }
3936}
3937impl serde::Serialize for DynamicFilterNode {
3938 #[allow(deprecated)]
3939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3940 where
3941 S: serde::Serializer,
3942 {
3943 use serde::ser::SerializeStruct;
3944 let mut len = 0;
3945 if self.left_key != 0 {
3946 len += 1;
3947 }
3948 if self.condition.is_some() {
3949 len += 1;
3950 }
3951 if self.left_table.is_some() {
3952 len += 1;
3953 }
3954 if self.right_table.is_some() {
3955 len += 1;
3956 }
3957 if self.condition_always_relax {
3958 len += 1;
3959 }
3960 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
3961 if self.left_key != 0 {
3962 struct_ser.serialize_field("leftKey", &self.left_key)?;
3963 }
3964 if let Some(v) = self.condition.as_ref() {
3965 struct_ser.serialize_field("condition", v)?;
3966 }
3967 if let Some(v) = self.left_table.as_ref() {
3968 struct_ser.serialize_field("leftTable", v)?;
3969 }
3970 if let Some(v) = self.right_table.as_ref() {
3971 struct_ser.serialize_field("rightTable", v)?;
3972 }
3973 if self.condition_always_relax {
3974 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
3975 }
3976 struct_ser.end()
3977 }
3978}
3979impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
3980 #[allow(deprecated)]
3981 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3982 where
3983 D: serde::Deserializer<'de>,
3984 {
3985 const FIELDS: &[&str] = &[
3986 "left_key",
3987 "leftKey",
3988 "condition",
3989 "left_table",
3990 "leftTable",
3991 "right_table",
3992 "rightTable",
3993 "condition_always_relax",
3994 "conditionAlwaysRelax",
3995 ];
3996
3997 #[allow(clippy::enum_variant_names)]
3998 enum GeneratedField {
3999 LeftKey,
4000 Condition,
4001 LeftTable,
4002 RightTable,
4003 ConditionAlwaysRelax,
4004 }
4005 impl<'de> serde::Deserialize<'de> for GeneratedField {
4006 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4007 where
4008 D: serde::Deserializer<'de>,
4009 {
4010 struct GeneratedVisitor;
4011
4012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4013 type Value = GeneratedField;
4014
4015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4016 write!(formatter, "expected one of: {:?}", &FIELDS)
4017 }
4018
4019 #[allow(unused_variables)]
4020 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4021 where
4022 E: serde::de::Error,
4023 {
4024 match value {
4025 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4026 "condition" => Ok(GeneratedField::Condition),
4027 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4028 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4029 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4030 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4031 }
4032 }
4033 }
4034 deserializer.deserialize_identifier(GeneratedVisitor)
4035 }
4036 }
4037 struct GeneratedVisitor;
4038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4039 type Value = DynamicFilterNode;
4040
4041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4042 formatter.write_str("struct stream_plan.DynamicFilterNode")
4043 }
4044
4045 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4046 where
4047 V: serde::de::MapAccess<'de>,
4048 {
4049 let mut left_key__ = None;
4050 let mut condition__ = None;
4051 let mut left_table__ = None;
4052 let mut right_table__ = None;
4053 let mut condition_always_relax__ = None;
4054 while let Some(k) = map_.next_key()? {
4055 match k {
4056 GeneratedField::LeftKey => {
4057 if left_key__.is_some() {
4058 return Err(serde::de::Error::duplicate_field("leftKey"));
4059 }
4060 left_key__ =
4061 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4062 ;
4063 }
4064 GeneratedField::Condition => {
4065 if condition__.is_some() {
4066 return Err(serde::de::Error::duplicate_field("condition"));
4067 }
4068 condition__ = map_.next_value()?;
4069 }
4070 GeneratedField::LeftTable => {
4071 if left_table__.is_some() {
4072 return Err(serde::de::Error::duplicate_field("leftTable"));
4073 }
4074 left_table__ = map_.next_value()?;
4075 }
4076 GeneratedField::RightTable => {
4077 if right_table__.is_some() {
4078 return Err(serde::de::Error::duplicate_field("rightTable"));
4079 }
4080 right_table__ = map_.next_value()?;
4081 }
4082 GeneratedField::ConditionAlwaysRelax => {
4083 if condition_always_relax__.is_some() {
4084 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4085 }
4086 condition_always_relax__ = Some(map_.next_value()?);
4087 }
4088 }
4089 }
4090 Ok(DynamicFilterNode {
4091 left_key: left_key__.unwrap_or_default(),
4092 condition: condition__,
4093 left_table: left_table__,
4094 right_table: right_table__,
4095 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4096 })
4097 }
4098 }
4099 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4100 }
4101}
4102impl serde::Serialize for EowcOverWindowNode {
4103 #[allow(deprecated)]
4104 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4105 where
4106 S: serde::Serializer,
4107 {
4108 use serde::ser::SerializeStruct;
4109 let mut len = 0;
4110 if !self.calls.is_empty() {
4111 len += 1;
4112 }
4113 if !self.partition_by.is_empty() {
4114 len += 1;
4115 }
4116 if !self.order_by.is_empty() {
4117 len += 1;
4118 }
4119 if self.state_table.is_some() {
4120 len += 1;
4121 }
4122 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4123 if !self.calls.is_empty() {
4124 struct_ser.serialize_field("calls", &self.calls)?;
4125 }
4126 if !self.partition_by.is_empty() {
4127 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4128 }
4129 if !self.order_by.is_empty() {
4130 struct_ser.serialize_field("orderBy", &self.order_by)?;
4131 }
4132 if let Some(v) = self.state_table.as_ref() {
4133 struct_ser.serialize_field("stateTable", v)?;
4134 }
4135 struct_ser.end()
4136 }
4137}
4138impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4139 #[allow(deprecated)]
4140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4141 where
4142 D: serde::Deserializer<'de>,
4143 {
4144 const FIELDS: &[&str] = &[
4145 "calls",
4146 "partition_by",
4147 "partitionBy",
4148 "order_by",
4149 "orderBy",
4150 "state_table",
4151 "stateTable",
4152 ];
4153
4154 #[allow(clippy::enum_variant_names)]
4155 enum GeneratedField {
4156 Calls,
4157 PartitionBy,
4158 OrderBy,
4159 StateTable,
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 "calls" => Ok(GeneratedField::Calls),
4182 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4183 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4184 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4185 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4186 }
4187 }
4188 }
4189 deserializer.deserialize_identifier(GeneratedVisitor)
4190 }
4191 }
4192 struct GeneratedVisitor;
4193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4194 type Value = EowcOverWindowNode;
4195
4196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4197 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4198 }
4199
4200 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4201 where
4202 V: serde::de::MapAccess<'de>,
4203 {
4204 let mut calls__ = None;
4205 let mut partition_by__ = None;
4206 let mut order_by__ = None;
4207 let mut state_table__ = None;
4208 while let Some(k) = map_.next_key()? {
4209 match k {
4210 GeneratedField::Calls => {
4211 if calls__.is_some() {
4212 return Err(serde::de::Error::duplicate_field("calls"));
4213 }
4214 calls__ = Some(map_.next_value()?);
4215 }
4216 GeneratedField::PartitionBy => {
4217 if partition_by__.is_some() {
4218 return Err(serde::de::Error::duplicate_field("partitionBy"));
4219 }
4220 partition_by__ =
4221 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4222 .into_iter().map(|x| x.0).collect())
4223 ;
4224 }
4225 GeneratedField::OrderBy => {
4226 if order_by__.is_some() {
4227 return Err(serde::de::Error::duplicate_field("orderBy"));
4228 }
4229 order_by__ = Some(map_.next_value()?);
4230 }
4231 GeneratedField::StateTable => {
4232 if state_table__.is_some() {
4233 return Err(serde::de::Error::duplicate_field("stateTable"));
4234 }
4235 state_table__ = map_.next_value()?;
4236 }
4237 }
4238 }
4239 Ok(EowcOverWindowNode {
4240 calls: calls__.unwrap_or_default(),
4241 partition_by: partition_by__.unwrap_or_default(),
4242 order_by: order_by__.unwrap_or_default(),
4243 state_table: state_table__,
4244 })
4245 }
4246 }
4247 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4248 }
4249}
4250impl serde::Serialize for ExchangeNode {
4251 #[allow(deprecated)]
4252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4253 where
4254 S: serde::Serializer,
4255 {
4256 use serde::ser::SerializeStruct;
4257 let mut len = 0;
4258 if self.strategy.is_some() {
4259 len += 1;
4260 }
4261 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4262 if let Some(v) = self.strategy.as_ref() {
4263 struct_ser.serialize_field("strategy", v)?;
4264 }
4265 struct_ser.end()
4266 }
4267}
4268impl<'de> serde::Deserialize<'de> for ExchangeNode {
4269 #[allow(deprecated)]
4270 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4271 where
4272 D: serde::Deserializer<'de>,
4273 {
4274 const FIELDS: &[&str] = &[
4275 "strategy",
4276 ];
4277
4278 #[allow(clippy::enum_variant_names)]
4279 enum GeneratedField {
4280 Strategy,
4281 }
4282 impl<'de> serde::Deserialize<'de> for GeneratedField {
4283 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4284 where
4285 D: serde::Deserializer<'de>,
4286 {
4287 struct GeneratedVisitor;
4288
4289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4290 type Value = GeneratedField;
4291
4292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4293 write!(formatter, "expected one of: {:?}", &FIELDS)
4294 }
4295
4296 #[allow(unused_variables)]
4297 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4298 where
4299 E: serde::de::Error,
4300 {
4301 match value {
4302 "strategy" => Ok(GeneratedField::Strategy),
4303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4304 }
4305 }
4306 }
4307 deserializer.deserialize_identifier(GeneratedVisitor)
4308 }
4309 }
4310 struct GeneratedVisitor;
4311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4312 type Value = ExchangeNode;
4313
4314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4315 formatter.write_str("struct stream_plan.ExchangeNode")
4316 }
4317
4318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4319 where
4320 V: serde::de::MapAccess<'de>,
4321 {
4322 let mut strategy__ = None;
4323 while let Some(k) = map_.next_key()? {
4324 match k {
4325 GeneratedField::Strategy => {
4326 if strategy__.is_some() {
4327 return Err(serde::de::Error::duplicate_field("strategy"));
4328 }
4329 strategy__ = map_.next_value()?;
4330 }
4331 }
4332 }
4333 Ok(ExchangeNode {
4334 strategy: strategy__,
4335 })
4336 }
4337 }
4338 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4339 }
4340}
4341impl serde::Serialize for ExpandNode {
4342 #[allow(deprecated)]
4343 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4344 where
4345 S: serde::Serializer,
4346 {
4347 use serde::ser::SerializeStruct;
4348 let mut len = 0;
4349 if !self.column_subsets.is_empty() {
4350 len += 1;
4351 }
4352 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4353 if !self.column_subsets.is_empty() {
4354 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4355 }
4356 struct_ser.end()
4357 }
4358}
4359impl<'de> serde::Deserialize<'de> for ExpandNode {
4360 #[allow(deprecated)]
4361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4362 where
4363 D: serde::Deserializer<'de>,
4364 {
4365 const FIELDS: &[&str] = &[
4366 "column_subsets",
4367 "columnSubsets",
4368 ];
4369
4370 #[allow(clippy::enum_variant_names)]
4371 enum GeneratedField {
4372 ColumnSubsets,
4373 }
4374 impl<'de> serde::Deserialize<'de> for GeneratedField {
4375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4376 where
4377 D: serde::Deserializer<'de>,
4378 {
4379 struct GeneratedVisitor;
4380
4381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4382 type Value = GeneratedField;
4383
4384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4385 write!(formatter, "expected one of: {:?}", &FIELDS)
4386 }
4387
4388 #[allow(unused_variables)]
4389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4390 where
4391 E: serde::de::Error,
4392 {
4393 match value {
4394 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4395 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4396 }
4397 }
4398 }
4399 deserializer.deserialize_identifier(GeneratedVisitor)
4400 }
4401 }
4402 struct GeneratedVisitor;
4403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4404 type Value = ExpandNode;
4405
4406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4407 formatter.write_str("struct stream_plan.ExpandNode")
4408 }
4409
4410 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4411 where
4412 V: serde::de::MapAccess<'de>,
4413 {
4414 let mut column_subsets__ = None;
4415 while let Some(k) = map_.next_key()? {
4416 match k {
4417 GeneratedField::ColumnSubsets => {
4418 if column_subsets__.is_some() {
4419 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4420 }
4421 column_subsets__ = Some(map_.next_value()?);
4422 }
4423 }
4424 }
4425 Ok(ExpandNode {
4426 column_subsets: column_subsets__.unwrap_or_default(),
4427 })
4428 }
4429 }
4430 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4431 }
4432}
4433impl serde::Serialize for expand_node::Subset {
4434 #[allow(deprecated)]
4435 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4436 where
4437 S: serde::Serializer,
4438 {
4439 use serde::ser::SerializeStruct;
4440 let mut len = 0;
4441 if !self.column_indices.is_empty() {
4442 len += 1;
4443 }
4444 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4445 if !self.column_indices.is_empty() {
4446 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4447 }
4448 struct_ser.end()
4449 }
4450}
4451impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4452 #[allow(deprecated)]
4453 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4454 where
4455 D: serde::Deserializer<'de>,
4456 {
4457 const FIELDS: &[&str] = &[
4458 "column_indices",
4459 "columnIndices",
4460 ];
4461
4462 #[allow(clippy::enum_variant_names)]
4463 enum GeneratedField {
4464 ColumnIndices,
4465 }
4466 impl<'de> serde::Deserialize<'de> for GeneratedField {
4467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4468 where
4469 D: serde::Deserializer<'de>,
4470 {
4471 struct GeneratedVisitor;
4472
4473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4474 type Value = GeneratedField;
4475
4476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4477 write!(formatter, "expected one of: {:?}", &FIELDS)
4478 }
4479
4480 #[allow(unused_variables)]
4481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4482 where
4483 E: serde::de::Error,
4484 {
4485 match value {
4486 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4488 }
4489 }
4490 }
4491 deserializer.deserialize_identifier(GeneratedVisitor)
4492 }
4493 }
4494 struct GeneratedVisitor;
4495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4496 type Value = expand_node::Subset;
4497
4498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4499 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4500 }
4501
4502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4503 where
4504 V: serde::de::MapAccess<'de>,
4505 {
4506 let mut column_indices__ = None;
4507 while let Some(k) = map_.next_key()? {
4508 match k {
4509 GeneratedField::ColumnIndices => {
4510 if column_indices__.is_some() {
4511 return Err(serde::de::Error::duplicate_field("columnIndices"));
4512 }
4513 column_indices__ =
4514 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4515 .into_iter().map(|x| x.0).collect())
4516 ;
4517 }
4518 }
4519 }
4520 Ok(expand_node::Subset {
4521 column_indices: column_indices__.unwrap_or_default(),
4522 })
4523 }
4524 }
4525 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4526 }
4527}
4528impl serde::Serialize for FilterNode {
4529 #[allow(deprecated)]
4530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4531 where
4532 S: serde::Serializer,
4533 {
4534 use serde::ser::SerializeStruct;
4535 let mut len = 0;
4536 if self.search_condition.is_some() {
4537 len += 1;
4538 }
4539 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4540 if let Some(v) = self.search_condition.as_ref() {
4541 struct_ser.serialize_field("searchCondition", v)?;
4542 }
4543 struct_ser.end()
4544 }
4545}
4546impl<'de> serde::Deserialize<'de> for FilterNode {
4547 #[allow(deprecated)]
4548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4549 where
4550 D: serde::Deserializer<'de>,
4551 {
4552 const FIELDS: &[&str] = &[
4553 "search_condition",
4554 "searchCondition",
4555 ];
4556
4557 #[allow(clippy::enum_variant_names)]
4558 enum GeneratedField {
4559 SearchCondition,
4560 }
4561 impl<'de> serde::Deserialize<'de> for GeneratedField {
4562 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4563 where
4564 D: serde::Deserializer<'de>,
4565 {
4566 struct GeneratedVisitor;
4567
4568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4569 type Value = GeneratedField;
4570
4571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4572 write!(formatter, "expected one of: {:?}", &FIELDS)
4573 }
4574
4575 #[allow(unused_variables)]
4576 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4577 where
4578 E: serde::de::Error,
4579 {
4580 match value {
4581 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4582 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4583 }
4584 }
4585 }
4586 deserializer.deserialize_identifier(GeneratedVisitor)
4587 }
4588 }
4589 struct GeneratedVisitor;
4590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4591 type Value = FilterNode;
4592
4593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4594 formatter.write_str("struct stream_plan.FilterNode")
4595 }
4596
4597 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4598 where
4599 V: serde::de::MapAccess<'de>,
4600 {
4601 let mut search_condition__ = None;
4602 while let Some(k) = map_.next_key()? {
4603 match k {
4604 GeneratedField::SearchCondition => {
4605 if search_condition__.is_some() {
4606 return Err(serde::de::Error::duplicate_field("searchCondition"));
4607 }
4608 search_condition__ = map_.next_value()?;
4609 }
4610 }
4611 }
4612 Ok(FilterNode {
4613 search_condition: search_condition__,
4614 })
4615 }
4616 }
4617 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4618 }
4619}
4620impl serde::Serialize for GlobalApproxPercentileNode {
4621 #[allow(deprecated)]
4622 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4623 where
4624 S: serde::Serializer,
4625 {
4626 use serde::ser::SerializeStruct;
4627 let mut len = 0;
4628 if self.base != 0. {
4629 len += 1;
4630 }
4631 if self.quantile != 0. {
4632 len += 1;
4633 }
4634 if self.bucket_state_table.is_some() {
4635 len += 1;
4636 }
4637 if self.count_state_table.is_some() {
4638 len += 1;
4639 }
4640 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4641 if self.base != 0. {
4642 struct_ser.serialize_field("base", &self.base)?;
4643 }
4644 if self.quantile != 0. {
4645 struct_ser.serialize_field("quantile", &self.quantile)?;
4646 }
4647 if let Some(v) = self.bucket_state_table.as_ref() {
4648 struct_ser.serialize_field("bucketStateTable", v)?;
4649 }
4650 if let Some(v) = self.count_state_table.as_ref() {
4651 struct_ser.serialize_field("countStateTable", v)?;
4652 }
4653 struct_ser.end()
4654 }
4655}
4656impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4657 #[allow(deprecated)]
4658 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4659 where
4660 D: serde::Deserializer<'de>,
4661 {
4662 const FIELDS: &[&str] = &[
4663 "base",
4664 "quantile",
4665 "bucket_state_table",
4666 "bucketStateTable",
4667 "count_state_table",
4668 "countStateTable",
4669 ];
4670
4671 #[allow(clippy::enum_variant_names)]
4672 enum GeneratedField {
4673 Base,
4674 Quantile,
4675 BucketStateTable,
4676 CountStateTable,
4677 }
4678 impl<'de> serde::Deserialize<'de> for GeneratedField {
4679 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4680 where
4681 D: serde::Deserializer<'de>,
4682 {
4683 struct GeneratedVisitor;
4684
4685 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4686 type Value = GeneratedField;
4687
4688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4689 write!(formatter, "expected one of: {:?}", &FIELDS)
4690 }
4691
4692 #[allow(unused_variables)]
4693 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4694 where
4695 E: serde::de::Error,
4696 {
4697 match value {
4698 "base" => Ok(GeneratedField::Base),
4699 "quantile" => Ok(GeneratedField::Quantile),
4700 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4701 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4702 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4703 }
4704 }
4705 }
4706 deserializer.deserialize_identifier(GeneratedVisitor)
4707 }
4708 }
4709 struct GeneratedVisitor;
4710 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4711 type Value = GlobalApproxPercentileNode;
4712
4713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4714 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4715 }
4716
4717 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4718 where
4719 V: serde::de::MapAccess<'de>,
4720 {
4721 let mut base__ = None;
4722 let mut quantile__ = None;
4723 let mut bucket_state_table__ = None;
4724 let mut count_state_table__ = None;
4725 while let Some(k) = map_.next_key()? {
4726 match k {
4727 GeneratedField::Base => {
4728 if base__.is_some() {
4729 return Err(serde::de::Error::duplicate_field("base"));
4730 }
4731 base__ =
4732 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4733 ;
4734 }
4735 GeneratedField::Quantile => {
4736 if quantile__.is_some() {
4737 return Err(serde::de::Error::duplicate_field("quantile"));
4738 }
4739 quantile__ =
4740 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4741 ;
4742 }
4743 GeneratedField::BucketStateTable => {
4744 if bucket_state_table__.is_some() {
4745 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4746 }
4747 bucket_state_table__ = map_.next_value()?;
4748 }
4749 GeneratedField::CountStateTable => {
4750 if count_state_table__.is_some() {
4751 return Err(serde::de::Error::duplicate_field("countStateTable"));
4752 }
4753 count_state_table__ = map_.next_value()?;
4754 }
4755 }
4756 }
4757 Ok(GlobalApproxPercentileNode {
4758 base: base__.unwrap_or_default(),
4759 quantile: quantile__.unwrap_or_default(),
4760 bucket_state_table: bucket_state_table__,
4761 count_state_table: count_state_table__,
4762 })
4763 }
4764 }
4765 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4766 }
4767}
4768impl serde::Serialize for GroupTopNNode {
4769 #[allow(deprecated)]
4770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4771 where
4772 S: serde::Serializer,
4773 {
4774 use serde::ser::SerializeStruct;
4775 let mut len = 0;
4776 if self.limit != 0 {
4777 len += 1;
4778 }
4779 if self.offset != 0 {
4780 len += 1;
4781 }
4782 if !self.group_key.is_empty() {
4783 len += 1;
4784 }
4785 if self.table.is_some() {
4786 len += 1;
4787 }
4788 if !self.order_by.is_empty() {
4789 len += 1;
4790 }
4791 if self.with_ties {
4792 len += 1;
4793 }
4794 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
4795 if self.limit != 0 {
4796 #[allow(clippy::needless_borrow)]
4797 #[allow(clippy::needless_borrows_for_generic_args)]
4798 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
4799 }
4800 if self.offset != 0 {
4801 #[allow(clippy::needless_borrow)]
4802 #[allow(clippy::needless_borrows_for_generic_args)]
4803 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
4804 }
4805 if !self.group_key.is_empty() {
4806 struct_ser.serialize_field("groupKey", &self.group_key)?;
4807 }
4808 if let Some(v) = self.table.as_ref() {
4809 struct_ser.serialize_field("table", v)?;
4810 }
4811 if !self.order_by.is_empty() {
4812 struct_ser.serialize_field("orderBy", &self.order_by)?;
4813 }
4814 if self.with_ties {
4815 struct_ser.serialize_field("withTies", &self.with_ties)?;
4816 }
4817 struct_ser.end()
4818 }
4819}
4820impl<'de> serde::Deserialize<'de> for GroupTopNNode {
4821 #[allow(deprecated)]
4822 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4823 where
4824 D: serde::Deserializer<'de>,
4825 {
4826 const FIELDS: &[&str] = &[
4827 "limit",
4828 "offset",
4829 "group_key",
4830 "groupKey",
4831 "table",
4832 "order_by",
4833 "orderBy",
4834 "with_ties",
4835 "withTies",
4836 ];
4837
4838 #[allow(clippy::enum_variant_names)]
4839 enum GeneratedField {
4840 Limit,
4841 Offset,
4842 GroupKey,
4843 Table,
4844 OrderBy,
4845 WithTies,
4846 }
4847 impl<'de> serde::Deserialize<'de> for GeneratedField {
4848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4849 where
4850 D: serde::Deserializer<'de>,
4851 {
4852 struct GeneratedVisitor;
4853
4854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4855 type Value = GeneratedField;
4856
4857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4858 write!(formatter, "expected one of: {:?}", &FIELDS)
4859 }
4860
4861 #[allow(unused_variables)]
4862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4863 where
4864 E: serde::de::Error,
4865 {
4866 match value {
4867 "limit" => Ok(GeneratedField::Limit),
4868 "offset" => Ok(GeneratedField::Offset),
4869 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
4870 "table" => Ok(GeneratedField::Table),
4871 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4872 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
4873 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4874 }
4875 }
4876 }
4877 deserializer.deserialize_identifier(GeneratedVisitor)
4878 }
4879 }
4880 struct GeneratedVisitor;
4881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4882 type Value = GroupTopNNode;
4883
4884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4885 formatter.write_str("struct stream_plan.GroupTopNNode")
4886 }
4887
4888 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
4889 where
4890 V: serde::de::MapAccess<'de>,
4891 {
4892 let mut limit__ = None;
4893 let mut offset__ = None;
4894 let mut group_key__ = None;
4895 let mut table__ = None;
4896 let mut order_by__ = None;
4897 let mut with_ties__ = None;
4898 while let Some(k) = map_.next_key()? {
4899 match k {
4900 GeneratedField::Limit => {
4901 if limit__.is_some() {
4902 return Err(serde::de::Error::duplicate_field("limit"));
4903 }
4904 limit__ =
4905 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4906 ;
4907 }
4908 GeneratedField::Offset => {
4909 if offset__.is_some() {
4910 return Err(serde::de::Error::duplicate_field("offset"));
4911 }
4912 offset__ =
4913 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4914 ;
4915 }
4916 GeneratedField::GroupKey => {
4917 if group_key__.is_some() {
4918 return Err(serde::de::Error::duplicate_field("groupKey"));
4919 }
4920 group_key__ =
4921 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4922 .into_iter().map(|x| x.0).collect())
4923 ;
4924 }
4925 GeneratedField::Table => {
4926 if table__.is_some() {
4927 return Err(serde::de::Error::duplicate_field("table"));
4928 }
4929 table__ = map_.next_value()?;
4930 }
4931 GeneratedField::OrderBy => {
4932 if order_by__.is_some() {
4933 return Err(serde::de::Error::duplicate_field("orderBy"));
4934 }
4935 order_by__ = Some(map_.next_value()?);
4936 }
4937 GeneratedField::WithTies => {
4938 if with_ties__.is_some() {
4939 return Err(serde::de::Error::duplicate_field("withTies"));
4940 }
4941 with_ties__ = Some(map_.next_value()?);
4942 }
4943 }
4944 }
4945 Ok(GroupTopNNode {
4946 limit: limit__.unwrap_or_default(),
4947 offset: offset__.unwrap_or_default(),
4948 group_key: group_key__.unwrap_or_default(),
4949 table: table__,
4950 order_by: order_by__.unwrap_or_default(),
4951 with_ties: with_ties__.unwrap_or_default(),
4952 })
4953 }
4954 }
4955 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
4956 }
4957}
4958impl serde::Serialize for HashAggNode {
4959 #[allow(deprecated)]
4960 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4961 where
4962 S: serde::Serializer,
4963 {
4964 use serde::ser::SerializeStruct;
4965 let mut len = 0;
4966 if !self.group_key.is_empty() {
4967 len += 1;
4968 }
4969 if !self.agg_calls.is_empty() {
4970 len += 1;
4971 }
4972 if !self.agg_call_states.is_empty() {
4973 len += 1;
4974 }
4975 if self.intermediate_state_table.is_some() {
4976 len += 1;
4977 }
4978 if self.is_append_only {
4979 len += 1;
4980 }
4981 if !self.distinct_dedup_tables.is_empty() {
4982 len += 1;
4983 }
4984 if self.row_count_index != 0 {
4985 len += 1;
4986 }
4987 if self.emit_on_window_close {
4988 len += 1;
4989 }
4990 if self.version != 0 {
4991 len += 1;
4992 }
4993 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
4994 if !self.group_key.is_empty() {
4995 struct_ser.serialize_field("groupKey", &self.group_key)?;
4996 }
4997 if !self.agg_calls.is_empty() {
4998 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
4999 }
5000 if !self.agg_call_states.is_empty() {
5001 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5002 }
5003 if let Some(v) = self.intermediate_state_table.as_ref() {
5004 struct_ser.serialize_field("intermediateStateTable", v)?;
5005 }
5006 if self.is_append_only {
5007 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5008 }
5009 if !self.distinct_dedup_tables.is_empty() {
5010 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5011 }
5012 if self.row_count_index != 0 {
5013 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5014 }
5015 if self.emit_on_window_close {
5016 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5017 }
5018 if self.version != 0 {
5019 let v = AggNodeVersion::try_from(self.version)
5020 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5021 struct_ser.serialize_field("version", &v)?;
5022 }
5023 struct_ser.end()
5024 }
5025}
5026impl<'de> serde::Deserialize<'de> for HashAggNode {
5027 #[allow(deprecated)]
5028 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5029 where
5030 D: serde::Deserializer<'de>,
5031 {
5032 const FIELDS: &[&str] = &[
5033 "group_key",
5034 "groupKey",
5035 "agg_calls",
5036 "aggCalls",
5037 "agg_call_states",
5038 "aggCallStates",
5039 "intermediate_state_table",
5040 "intermediateStateTable",
5041 "is_append_only",
5042 "isAppendOnly",
5043 "distinct_dedup_tables",
5044 "distinctDedupTables",
5045 "row_count_index",
5046 "rowCountIndex",
5047 "emit_on_window_close",
5048 "emitOnWindowClose",
5049 "version",
5050 ];
5051
5052 #[allow(clippy::enum_variant_names)]
5053 enum GeneratedField {
5054 GroupKey,
5055 AggCalls,
5056 AggCallStates,
5057 IntermediateStateTable,
5058 IsAppendOnly,
5059 DistinctDedupTables,
5060 RowCountIndex,
5061 EmitOnWindowClose,
5062 Version,
5063 }
5064 impl<'de> serde::Deserialize<'de> for GeneratedField {
5065 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5066 where
5067 D: serde::Deserializer<'de>,
5068 {
5069 struct GeneratedVisitor;
5070
5071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5072 type Value = GeneratedField;
5073
5074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5075 write!(formatter, "expected one of: {:?}", &FIELDS)
5076 }
5077
5078 #[allow(unused_variables)]
5079 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5080 where
5081 E: serde::de::Error,
5082 {
5083 match value {
5084 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5085 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5086 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5087 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5088 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5089 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5090 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5091 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5092 "version" => Ok(GeneratedField::Version),
5093 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5094 }
5095 }
5096 }
5097 deserializer.deserialize_identifier(GeneratedVisitor)
5098 }
5099 }
5100 struct GeneratedVisitor;
5101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5102 type Value = HashAggNode;
5103
5104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5105 formatter.write_str("struct stream_plan.HashAggNode")
5106 }
5107
5108 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5109 where
5110 V: serde::de::MapAccess<'de>,
5111 {
5112 let mut group_key__ = None;
5113 let mut agg_calls__ = None;
5114 let mut agg_call_states__ = None;
5115 let mut intermediate_state_table__ = None;
5116 let mut is_append_only__ = None;
5117 let mut distinct_dedup_tables__ = None;
5118 let mut row_count_index__ = None;
5119 let mut emit_on_window_close__ = None;
5120 let mut version__ = None;
5121 while let Some(k) = map_.next_key()? {
5122 match k {
5123 GeneratedField::GroupKey => {
5124 if group_key__.is_some() {
5125 return Err(serde::de::Error::duplicate_field("groupKey"));
5126 }
5127 group_key__ =
5128 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5129 .into_iter().map(|x| x.0).collect())
5130 ;
5131 }
5132 GeneratedField::AggCalls => {
5133 if agg_calls__.is_some() {
5134 return Err(serde::de::Error::duplicate_field("aggCalls"));
5135 }
5136 agg_calls__ = Some(map_.next_value()?);
5137 }
5138 GeneratedField::AggCallStates => {
5139 if agg_call_states__.is_some() {
5140 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5141 }
5142 agg_call_states__ = Some(map_.next_value()?);
5143 }
5144 GeneratedField::IntermediateStateTable => {
5145 if intermediate_state_table__.is_some() {
5146 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5147 }
5148 intermediate_state_table__ = map_.next_value()?;
5149 }
5150 GeneratedField::IsAppendOnly => {
5151 if is_append_only__.is_some() {
5152 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5153 }
5154 is_append_only__ = Some(map_.next_value()?);
5155 }
5156 GeneratedField::DistinctDedupTables => {
5157 if distinct_dedup_tables__.is_some() {
5158 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5159 }
5160 distinct_dedup_tables__ = Some(
5161 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5162 .into_iter().map(|(k,v)| (k.0, v)).collect()
5163 );
5164 }
5165 GeneratedField::RowCountIndex => {
5166 if row_count_index__.is_some() {
5167 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5168 }
5169 row_count_index__ =
5170 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5171 ;
5172 }
5173 GeneratedField::EmitOnWindowClose => {
5174 if emit_on_window_close__.is_some() {
5175 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5176 }
5177 emit_on_window_close__ = Some(map_.next_value()?);
5178 }
5179 GeneratedField::Version => {
5180 if version__.is_some() {
5181 return Err(serde::de::Error::duplicate_field("version"));
5182 }
5183 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5184 }
5185 }
5186 }
5187 Ok(HashAggNode {
5188 group_key: group_key__.unwrap_or_default(),
5189 agg_calls: agg_calls__.unwrap_or_default(),
5190 agg_call_states: agg_call_states__.unwrap_or_default(),
5191 intermediate_state_table: intermediate_state_table__,
5192 is_append_only: is_append_only__.unwrap_or_default(),
5193 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5194 row_count_index: row_count_index__.unwrap_or_default(),
5195 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5196 version: version__.unwrap_or_default(),
5197 })
5198 }
5199 }
5200 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5201 }
5202}
5203impl serde::Serialize for HashJoinNode {
5204 #[allow(deprecated)]
5205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5206 where
5207 S: serde::Serializer,
5208 {
5209 use serde::ser::SerializeStruct;
5210 let mut len = 0;
5211 if self.join_type != 0 {
5212 len += 1;
5213 }
5214 if !self.left_key.is_empty() {
5215 len += 1;
5216 }
5217 if !self.right_key.is_empty() {
5218 len += 1;
5219 }
5220 if self.condition.is_some() {
5221 len += 1;
5222 }
5223 if !self.inequality_pairs.is_empty() {
5224 len += 1;
5225 }
5226 if self.left_table.is_some() {
5227 len += 1;
5228 }
5229 if self.right_table.is_some() {
5230 len += 1;
5231 }
5232 if self.left_degree_table.is_some() {
5233 len += 1;
5234 }
5235 if self.right_degree_table.is_some() {
5236 len += 1;
5237 }
5238 if !self.output_indices.is_empty() {
5239 len += 1;
5240 }
5241 if !self.left_deduped_input_pk_indices.is_empty() {
5242 len += 1;
5243 }
5244 if !self.right_deduped_input_pk_indices.is_empty() {
5245 len += 1;
5246 }
5247 if !self.null_safe.is_empty() {
5248 len += 1;
5249 }
5250 if self.is_append_only {
5251 len += 1;
5252 }
5253 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5254 if self.join_type != 0 {
5255 let v = super::plan_common::JoinType::try_from(self.join_type)
5256 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5257 struct_ser.serialize_field("joinType", &v)?;
5258 }
5259 if !self.left_key.is_empty() {
5260 struct_ser.serialize_field("leftKey", &self.left_key)?;
5261 }
5262 if !self.right_key.is_empty() {
5263 struct_ser.serialize_field("rightKey", &self.right_key)?;
5264 }
5265 if let Some(v) = self.condition.as_ref() {
5266 struct_ser.serialize_field("condition", v)?;
5267 }
5268 if !self.inequality_pairs.is_empty() {
5269 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5270 }
5271 if let Some(v) = self.left_table.as_ref() {
5272 struct_ser.serialize_field("leftTable", v)?;
5273 }
5274 if let Some(v) = self.right_table.as_ref() {
5275 struct_ser.serialize_field("rightTable", v)?;
5276 }
5277 if let Some(v) = self.left_degree_table.as_ref() {
5278 struct_ser.serialize_field("leftDegreeTable", v)?;
5279 }
5280 if let Some(v) = self.right_degree_table.as_ref() {
5281 struct_ser.serialize_field("rightDegreeTable", v)?;
5282 }
5283 if !self.output_indices.is_empty() {
5284 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5285 }
5286 if !self.left_deduped_input_pk_indices.is_empty() {
5287 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5288 }
5289 if !self.right_deduped_input_pk_indices.is_empty() {
5290 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5291 }
5292 if !self.null_safe.is_empty() {
5293 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5294 }
5295 if self.is_append_only {
5296 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5297 }
5298 struct_ser.end()
5299 }
5300}
5301impl<'de> serde::Deserialize<'de> for HashJoinNode {
5302 #[allow(deprecated)]
5303 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5304 where
5305 D: serde::Deserializer<'de>,
5306 {
5307 const FIELDS: &[&str] = &[
5308 "join_type",
5309 "joinType",
5310 "left_key",
5311 "leftKey",
5312 "right_key",
5313 "rightKey",
5314 "condition",
5315 "inequality_pairs",
5316 "inequalityPairs",
5317 "left_table",
5318 "leftTable",
5319 "right_table",
5320 "rightTable",
5321 "left_degree_table",
5322 "leftDegreeTable",
5323 "right_degree_table",
5324 "rightDegreeTable",
5325 "output_indices",
5326 "outputIndices",
5327 "left_deduped_input_pk_indices",
5328 "leftDedupedInputPkIndices",
5329 "right_deduped_input_pk_indices",
5330 "rightDedupedInputPkIndices",
5331 "null_safe",
5332 "nullSafe",
5333 "is_append_only",
5334 "isAppendOnly",
5335 ];
5336
5337 #[allow(clippy::enum_variant_names)]
5338 enum GeneratedField {
5339 JoinType,
5340 LeftKey,
5341 RightKey,
5342 Condition,
5343 InequalityPairs,
5344 LeftTable,
5345 RightTable,
5346 LeftDegreeTable,
5347 RightDegreeTable,
5348 OutputIndices,
5349 LeftDedupedInputPkIndices,
5350 RightDedupedInputPkIndices,
5351 NullSafe,
5352 IsAppendOnly,
5353 }
5354 impl<'de> serde::Deserialize<'de> for GeneratedField {
5355 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5356 where
5357 D: serde::Deserializer<'de>,
5358 {
5359 struct GeneratedVisitor;
5360
5361 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5362 type Value = GeneratedField;
5363
5364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5365 write!(formatter, "expected one of: {:?}", &FIELDS)
5366 }
5367
5368 #[allow(unused_variables)]
5369 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5370 where
5371 E: serde::de::Error,
5372 {
5373 match value {
5374 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5375 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5376 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5377 "condition" => Ok(GeneratedField::Condition),
5378 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5379 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5380 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5381 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5382 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5383 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5384 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5385 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5386 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5387 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5388 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5389 }
5390 }
5391 }
5392 deserializer.deserialize_identifier(GeneratedVisitor)
5393 }
5394 }
5395 struct GeneratedVisitor;
5396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5397 type Value = HashJoinNode;
5398
5399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5400 formatter.write_str("struct stream_plan.HashJoinNode")
5401 }
5402
5403 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5404 where
5405 V: serde::de::MapAccess<'de>,
5406 {
5407 let mut join_type__ = None;
5408 let mut left_key__ = None;
5409 let mut right_key__ = None;
5410 let mut condition__ = None;
5411 let mut inequality_pairs__ = None;
5412 let mut left_table__ = None;
5413 let mut right_table__ = None;
5414 let mut left_degree_table__ = None;
5415 let mut right_degree_table__ = None;
5416 let mut output_indices__ = None;
5417 let mut left_deduped_input_pk_indices__ = None;
5418 let mut right_deduped_input_pk_indices__ = None;
5419 let mut null_safe__ = None;
5420 let mut is_append_only__ = None;
5421 while let Some(k) = map_.next_key()? {
5422 match k {
5423 GeneratedField::JoinType => {
5424 if join_type__.is_some() {
5425 return Err(serde::de::Error::duplicate_field("joinType"));
5426 }
5427 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5428 }
5429 GeneratedField::LeftKey => {
5430 if left_key__.is_some() {
5431 return Err(serde::de::Error::duplicate_field("leftKey"));
5432 }
5433 left_key__ =
5434 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5435 .into_iter().map(|x| x.0).collect())
5436 ;
5437 }
5438 GeneratedField::RightKey => {
5439 if right_key__.is_some() {
5440 return Err(serde::de::Error::duplicate_field("rightKey"));
5441 }
5442 right_key__ =
5443 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5444 .into_iter().map(|x| x.0).collect())
5445 ;
5446 }
5447 GeneratedField::Condition => {
5448 if condition__.is_some() {
5449 return Err(serde::de::Error::duplicate_field("condition"));
5450 }
5451 condition__ = map_.next_value()?;
5452 }
5453 GeneratedField::InequalityPairs => {
5454 if inequality_pairs__.is_some() {
5455 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5456 }
5457 inequality_pairs__ = Some(map_.next_value()?);
5458 }
5459 GeneratedField::LeftTable => {
5460 if left_table__.is_some() {
5461 return Err(serde::de::Error::duplicate_field("leftTable"));
5462 }
5463 left_table__ = map_.next_value()?;
5464 }
5465 GeneratedField::RightTable => {
5466 if right_table__.is_some() {
5467 return Err(serde::de::Error::duplicate_field("rightTable"));
5468 }
5469 right_table__ = map_.next_value()?;
5470 }
5471 GeneratedField::LeftDegreeTable => {
5472 if left_degree_table__.is_some() {
5473 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5474 }
5475 left_degree_table__ = map_.next_value()?;
5476 }
5477 GeneratedField::RightDegreeTable => {
5478 if right_degree_table__.is_some() {
5479 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5480 }
5481 right_degree_table__ = map_.next_value()?;
5482 }
5483 GeneratedField::OutputIndices => {
5484 if output_indices__.is_some() {
5485 return Err(serde::de::Error::duplicate_field("outputIndices"));
5486 }
5487 output_indices__ =
5488 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5489 .into_iter().map(|x| x.0).collect())
5490 ;
5491 }
5492 GeneratedField::LeftDedupedInputPkIndices => {
5493 if left_deduped_input_pk_indices__.is_some() {
5494 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5495 }
5496 left_deduped_input_pk_indices__ =
5497 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5498 .into_iter().map(|x| x.0).collect())
5499 ;
5500 }
5501 GeneratedField::RightDedupedInputPkIndices => {
5502 if right_deduped_input_pk_indices__.is_some() {
5503 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5504 }
5505 right_deduped_input_pk_indices__ =
5506 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5507 .into_iter().map(|x| x.0).collect())
5508 ;
5509 }
5510 GeneratedField::NullSafe => {
5511 if null_safe__.is_some() {
5512 return Err(serde::de::Error::duplicate_field("nullSafe"));
5513 }
5514 null_safe__ = Some(map_.next_value()?);
5515 }
5516 GeneratedField::IsAppendOnly => {
5517 if is_append_only__.is_some() {
5518 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5519 }
5520 is_append_only__ = Some(map_.next_value()?);
5521 }
5522 }
5523 }
5524 Ok(HashJoinNode {
5525 join_type: join_type__.unwrap_or_default(),
5526 left_key: left_key__.unwrap_or_default(),
5527 right_key: right_key__.unwrap_or_default(),
5528 condition: condition__,
5529 inequality_pairs: inequality_pairs__.unwrap_or_default(),
5530 left_table: left_table__,
5531 right_table: right_table__,
5532 left_degree_table: left_degree_table__,
5533 right_degree_table: right_degree_table__,
5534 output_indices: output_indices__.unwrap_or_default(),
5535 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5536 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5537 null_safe: null_safe__.unwrap_or_default(),
5538 is_append_only: is_append_only__.unwrap_or_default(),
5539 })
5540 }
5541 }
5542 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5543 }
5544}
5545impl serde::Serialize for HopWindowNode {
5546 #[allow(deprecated)]
5547 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5548 where
5549 S: serde::Serializer,
5550 {
5551 use serde::ser::SerializeStruct;
5552 let mut len = 0;
5553 if self.time_col != 0 {
5554 len += 1;
5555 }
5556 if self.window_slide.is_some() {
5557 len += 1;
5558 }
5559 if self.window_size.is_some() {
5560 len += 1;
5561 }
5562 if !self.output_indices.is_empty() {
5563 len += 1;
5564 }
5565 if !self.window_start_exprs.is_empty() {
5566 len += 1;
5567 }
5568 if !self.window_end_exprs.is_empty() {
5569 len += 1;
5570 }
5571 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5572 if self.time_col != 0 {
5573 struct_ser.serialize_field("timeCol", &self.time_col)?;
5574 }
5575 if let Some(v) = self.window_slide.as_ref() {
5576 struct_ser.serialize_field("windowSlide", v)?;
5577 }
5578 if let Some(v) = self.window_size.as_ref() {
5579 struct_ser.serialize_field("windowSize", v)?;
5580 }
5581 if !self.output_indices.is_empty() {
5582 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5583 }
5584 if !self.window_start_exprs.is_empty() {
5585 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5586 }
5587 if !self.window_end_exprs.is_empty() {
5588 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5589 }
5590 struct_ser.end()
5591 }
5592}
5593impl<'de> serde::Deserialize<'de> for HopWindowNode {
5594 #[allow(deprecated)]
5595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5596 where
5597 D: serde::Deserializer<'de>,
5598 {
5599 const FIELDS: &[&str] = &[
5600 "time_col",
5601 "timeCol",
5602 "window_slide",
5603 "windowSlide",
5604 "window_size",
5605 "windowSize",
5606 "output_indices",
5607 "outputIndices",
5608 "window_start_exprs",
5609 "windowStartExprs",
5610 "window_end_exprs",
5611 "windowEndExprs",
5612 ];
5613
5614 #[allow(clippy::enum_variant_names)]
5615 enum GeneratedField {
5616 TimeCol,
5617 WindowSlide,
5618 WindowSize,
5619 OutputIndices,
5620 WindowStartExprs,
5621 WindowEndExprs,
5622 }
5623 impl<'de> serde::Deserialize<'de> for GeneratedField {
5624 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5625 where
5626 D: serde::Deserializer<'de>,
5627 {
5628 struct GeneratedVisitor;
5629
5630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5631 type Value = GeneratedField;
5632
5633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5634 write!(formatter, "expected one of: {:?}", &FIELDS)
5635 }
5636
5637 #[allow(unused_variables)]
5638 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5639 where
5640 E: serde::de::Error,
5641 {
5642 match value {
5643 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5644 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5645 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5646 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5647 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5648 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5649 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5650 }
5651 }
5652 }
5653 deserializer.deserialize_identifier(GeneratedVisitor)
5654 }
5655 }
5656 struct GeneratedVisitor;
5657 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5658 type Value = HopWindowNode;
5659
5660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5661 formatter.write_str("struct stream_plan.HopWindowNode")
5662 }
5663
5664 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5665 where
5666 V: serde::de::MapAccess<'de>,
5667 {
5668 let mut time_col__ = None;
5669 let mut window_slide__ = None;
5670 let mut window_size__ = None;
5671 let mut output_indices__ = None;
5672 let mut window_start_exprs__ = None;
5673 let mut window_end_exprs__ = None;
5674 while let Some(k) = map_.next_key()? {
5675 match k {
5676 GeneratedField::TimeCol => {
5677 if time_col__.is_some() {
5678 return Err(serde::de::Error::duplicate_field("timeCol"));
5679 }
5680 time_col__ =
5681 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5682 ;
5683 }
5684 GeneratedField::WindowSlide => {
5685 if window_slide__.is_some() {
5686 return Err(serde::de::Error::duplicate_field("windowSlide"));
5687 }
5688 window_slide__ = map_.next_value()?;
5689 }
5690 GeneratedField::WindowSize => {
5691 if window_size__.is_some() {
5692 return Err(serde::de::Error::duplicate_field("windowSize"));
5693 }
5694 window_size__ = map_.next_value()?;
5695 }
5696 GeneratedField::OutputIndices => {
5697 if output_indices__.is_some() {
5698 return Err(serde::de::Error::duplicate_field("outputIndices"));
5699 }
5700 output_indices__ =
5701 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5702 .into_iter().map(|x| x.0).collect())
5703 ;
5704 }
5705 GeneratedField::WindowStartExprs => {
5706 if window_start_exprs__.is_some() {
5707 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5708 }
5709 window_start_exprs__ = Some(map_.next_value()?);
5710 }
5711 GeneratedField::WindowEndExprs => {
5712 if window_end_exprs__.is_some() {
5713 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5714 }
5715 window_end_exprs__ = Some(map_.next_value()?);
5716 }
5717 }
5718 }
5719 Ok(HopWindowNode {
5720 time_col: time_col__.unwrap_or_default(),
5721 window_slide: window_slide__,
5722 window_size: window_size__,
5723 output_indices: output_indices__.unwrap_or_default(),
5724 window_start_exprs: window_start_exprs__.unwrap_or_default(),
5725 window_end_exprs: window_end_exprs__.unwrap_or_default(),
5726 })
5727 }
5728 }
5729 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5730 }
5731}
5732impl serde::Serialize for InequalityPair {
5733 #[allow(deprecated)]
5734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5735 where
5736 S: serde::Serializer,
5737 {
5738 use serde::ser::SerializeStruct;
5739 let mut len = 0;
5740 if self.key_required_larger != 0 {
5741 len += 1;
5742 }
5743 if self.key_required_smaller != 0 {
5744 len += 1;
5745 }
5746 if self.clean_state {
5747 len += 1;
5748 }
5749 if self.delta_expression.is_some() {
5750 len += 1;
5751 }
5752 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5753 if self.key_required_larger != 0 {
5754 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5755 }
5756 if self.key_required_smaller != 0 {
5757 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5758 }
5759 if self.clean_state {
5760 struct_ser.serialize_field("cleanState", &self.clean_state)?;
5761 }
5762 if let Some(v) = self.delta_expression.as_ref() {
5763 struct_ser.serialize_field("deltaExpression", v)?;
5764 }
5765 struct_ser.end()
5766 }
5767}
5768impl<'de> serde::Deserialize<'de> for InequalityPair {
5769 #[allow(deprecated)]
5770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5771 where
5772 D: serde::Deserializer<'de>,
5773 {
5774 const FIELDS: &[&str] = &[
5775 "key_required_larger",
5776 "keyRequiredLarger",
5777 "key_required_smaller",
5778 "keyRequiredSmaller",
5779 "clean_state",
5780 "cleanState",
5781 "delta_expression",
5782 "deltaExpression",
5783 ];
5784
5785 #[allow(clippy::enum_variant_names)]
5786 enum GeneratedField {
5787 KeyRequiredLarger,
5788 KeyRequiredSmaller,
5789 CleanState,
5790 DeltaExpression,
5791 }
5792 impl<'de> serde::Deserialize<'de> for GeneratedField {
5793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5794 where
5795 D: serde::Deserializer<'de>,
5796 {
5797 struct GeneratedVisitor;
5798
5799 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5800 type Value = GeneratedField;
5801
5802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5803 write!(formatter, "expected one of: {:?}", &FIELDS)
5804 }
5805
5806 #[allow(unused_variables)]
5807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5808 where
5809 E: serde::de::Error,
5810 {
5811 match value {
5812 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
5813 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
5814 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
5815 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
5816 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5817 }
5818 }
5819 }
5820 deserializer.deserialize_identifier(GeneratedVisitor)
5821 }
5822 }
5823 struct GeneratedVisitor;
5824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5825 type Value = InequalityPair;
5826
5827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5828 formatter.write_str("struct stream_plan.InequalityPair")
5829 }
5830
5831 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
5832 where
5833 V: serde::de::MapAccess<'de>,
5834 {
5835 let mut key_required_larger__ = None;
5836 let mut key_required_smaller__ = None;
5837 let mut clean_state__ = None;
5838 let mut delta_expression__ = None;
5839 while let Some(k) = map_.next_key()? {
5840 match k {
5841 GeneratedField::KeyRequiredLarger => {
5842 if key_required_larger__.is_some() {
5843 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
5844 }
5845 key_required_larger__ =
5846 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5847 ;
5848 }
5849 GeneratedField::KeyRequiredSmaller => {
5850 if key_required_smaller__.is_some() {
5851 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
5852 }
5853 key_required_smaller__ =
5854 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5855 ;
5856 }
5857 GeneratedField::CleanState => {
5858 if clean_state__.is_some() {
5859 return Err(serde::de::Error::duplicate_field("cleanState"));
5860 }
5861 clean_state__ = Some(map_.next_value()?);
5862 }
5863 GeneratedField::DeltaExpression => {
5864 if delta_expression__.is_some() {
5865 return Err(serde::de::Error::duplicate_field("deltaExpression"));
5866 }
5867 delta_expression__ = map_.next_value()?;
5868 }
5869 }
5870 }
5871 Ok(InequalityPair {
5872 key_required_larger: key_required_larger__.unwrap_or_default(),
5873 key_required_smaller: key_required_smaller__.unwrap_or_default(),
5874 clean_state: clean_state__.unwrap_or_default(),
5875 delta_expression: delta_expression__,
5876 })
5877 }
5878 }
5879 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
5880 }
5881}
5882impl serde::Serialize for LocalApproxPercentileNode {
5883 #[allow(deprecated)]
5884 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5885 where
5886 S: serde::Serializer,
5887 {
5888 use serde::ser::SerializeStruct;
5889 let mut len = 0;
5890 if self.base != 0. {
5891 len += 1;
5892 }
5893 if self.percentile_index != 0 {
5894 len += 1;
5895 }
5896 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
5897 if self.base != 0. {
5898 struct_ser.serialize_field("base", &self.base)?;
5899 }
5900 if self.percentile_index != 0 {
5901 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
5902 }
5903 struct_ser.end()
5904 }
5905}
5906impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
5907 #[allow(deprecated)]
5908 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5909 where
5910 D: serde::Deserializer<'de>,
5911 {
5912 const FIELDS: &[&str] = &[
5913 "base",
5914 "percentile_index",
5915 "percentileIndex",
5916 ];
5917
5918 #[allow(clippy::enum_variant_names)]
5919 enum GeneratedField {
5920 Base,
5921 PercentileIndex,
5922 }
5923 impl<'de> serde::Deserialize<'de> for GeneratedField {
5924 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5925 where
5926 D: serde::Deserializer<'de>,
5927 {
5928 struct GeneratedVisitor;
5929
5930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5931 type Value = GeneratedField;
5932
5933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5934 write!(formatter, "expected one of: {:?}", &FIELDS)
5935 }
5936
5937 #[allow(unused_variables)]
5938 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5939 where
5940 E: serde::de::Error,
5941 {
5942 match value {
5943 "base" => Ok(GeneratedField::Base),
5944 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
5945 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5946 }
5947 }
5948 }
5949 deserializer.deserialize_identifier(GeneratedVisitor)
5950 }
5951 }
5952 struct GeneratedVisitor;
5953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5954 type Value = LocalApproxPercentileNode;
5955
5956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5957 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
5958 }
5959
5960 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
5961 where
5962 V: serde::de::MapAccess<'de>,
5963 {
5964 let mut base__ = None;
5965 let mut percentile_index__ = None;
5966 while let Some(k) = map_.next_key()? {
5967 match k {
5968 GeneratedField::Base => {
5969 if base__.is_some() {
5970 return Err(serde::de::Error::duplicate_field("base"));
5971 }
5972 base__ =
5973 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5974 ;
5975 }
5976 GeneratedField::PercentileIndex => {
5977 if percentile_index__.is_some() {
5978 return Err(serde::de::Error::duplicate_field("percentileIndex"));
5979 }
5980 percentile_index__ =
5981 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5982 ;
5983 }
5984 }
5985 }
5986 Ok(LocalApproxPercentileNode {
5987 base: base__.unwrap_or_default(),
5988 percentile_index: percentile_index__.unwrap_or_default(),
5989 })
5990 }
5991 }
5992 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
5993 }
5994}
5995impl serde::Serialize for LookupNode {
5996 #[allow(deprecated)]
5997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5998 where
5999 S: serde::Serializer,
6000 {
6001 use serde::ser::SerializeStruct;
6002 let mut len = 0;
6003 if !self.arrange_key.is_empty() {
6004 len += 1;
6005 }
6006 if !self.stream_key.is_empty() {
6007 len += 1;
6008 }
6009 if self.use_current_epoch {
6010 len += 1;
6011 }
6012 if !self.column_mapping.is_empty() {
6013 len += 1;
6014 }
6015 if self.arrangement_table_info.is_some() {
6016 len += 1;
6017 }
6018 if self.arrangement_table_id.is_some() {
6019 len += 1;
6020 }
6021 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6022 if !self.arrange_key.is_empty() {
6023 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6024 }
6025 if !self.stream_key.is_empty() {
6026 struct_ser.serialize_field("streamKey", &self.stream_key)?;
6027 }
6028 if self.use_current_epoch {
6029 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6030 }
6031 if !self.column_mapping.is_empty() {
6032 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6033 }
6034 if let Some(v) = self.arrangement_table_info.as_ref() {
6035 struct_ser.serialize_field("arrangementTableInfo", v)?;
6036 }
6037 if let Some(v) = self.arrangement_table_id.as_ref() {
6038 match v {
6039 lookup_node::ArrangementTableId::TableId(v) => {
6040 struct_ser.serialize_field("tableId", v)?;
6041 }
6042 lookup_node::ArrangementTableId::IndexId(v) => {
6043 struct_ser.serialize_field("indexId", v)?;
6044 }
6045 }
6046 }
6047 struct_ser.end()
6048 }
6049}
6050impl<'de> serde::Deserialize<'de> for LookupNode {
6051 #[allow(deprecated)]
6052 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6053 where
6054 D: serde::Deserializer<'de>,
6055 {
6056 const FIELDS: &[&str] = &[
6057 "arrange_key",
6058 "arrangeKey",
6059 "stream_key",
6060 "streamKey",
6061 "use_current_epoch",
6062 "useCurrentEpoch",
6063 "column_mapping",
6064 "columnMapping",
6065 "arrangement_table_info",
6066 "arrangementTableInfo",
6067 "table_id",
6068 "tableId",
6069 "index_id",
6070 "indexId",
6071 ];
6072
6073 #[allow(clippy::enum_variant_names)]
6074 enum GeneratedField {
6075 ArrangeKey,
6076 StreamKey,
6077 UseCurrentEpoch,
6078 ColumnMapping,
6079 ArrangementTableInfo,
6080 TableId,
6081 IndexId,
6082 }
6083 impl<'de> serde::Deserialize<'de> for GeneratedField {
6084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6085 where
6086 D: serde::Deserializer<'de>,
6087 {
6088 struct GeneratedVisitor;
6089
6090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6091 type Value = GeneratedField;
6092
6093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6094 write!(formatter, "expected one of: {:?}", &FIELDS)
6095 }
6096
6097 #[allow(unused_variables)]
6098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6099 where
6100 E: serde::de::Error,
6101 {
6102 match value {
6103 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6104 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6105 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6106 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6107 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6108 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6109 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6110 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6111 }
6112 }
6113 }
6114 deserializer.deserialize_identifier(GeneratedVisitor)
6115 }
6116 }
6117 struct GeneratedVisitor;
6118 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6119 type Value = LookupNode;
6120
6121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6122 formatter.write_str("struct stream_plan.LookupNode")
6123 }
6124
6125 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6126 where
6127 V: serde::de::MapAccess<'de>,
6128 {
6129 let mut arrange_key__ = None;
6130 let mut stream_key__ = None;
6131 let mut use_current_epoch__ = None;
6132 let mut column_mapping__ = None;
6133 let mut arrangement_table_info__ = None;
6134 let mut arrangement_table_id__ = None;
6135 while let Some(k) = map_.next_key()? {
6136 match k {
6137 GeneratedField::ArrangeKey => {
6138 if arrange_key__.is_some() {
6139 return Err(serde::de::Error::duplicate_field("arrangeKey"));
6140 }
6141 arrange_key__ =
6142 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6143 .into_iter().map(|x| x.0).collect())
6144 ;
6145 }
6146 GeneratedField::StreamKey => {
6147 if stream_key__.is_some() {
6148 return Err(serde::de::Error::duplicate_field("streamKey"));
6149 }
6150 stream_key__ =
6151 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6152 .into_iter().map(|x| x.0).collect())
6153 ;
6154 }
6155 GeneratedField::UseCurrentEpoch => {
6156 if use_current_epoch__.is_some() {
6157 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6158 }
6159 use_current_epoch__ = Some(map_.next_value()?);
6160 }
6161 GeneratedField::ColumnMapping => {
6162 if column_mapping__.is_some() {
6163 return Err(serde::de::Error::duplicate_field("columnMapping"));
6164 }
6165 column_mapping__ =
6166 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6167 .into_iter().map(|x| x.0).collect())
6168 ;
6169 }
6170 GeneratedField::ArrangementTableInfo => {
6171 if arrangement_table_info__.is_some() {
6172 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6173 }
6174 arrangement_table_info__ = map_.next_value()?;
6175 }
6176 GeneratedField::TableId => {
6177 if arrangement_table_id__.is_some() {
6178 return Err(serde::de::Error::duplicate_field("tableId"));
6179 }
6180 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6181 }
6182 GeneratedField::IndexId => {
6183 if arrangement_table_id__.is_some() {
6184 return Err(serde::de::Error::duplicate_field("indexId"));
6185 }
6186 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6187 }
6188 }
6189 }
6190 Ok(LookupNode {
6191 arrange_key: arrange_key__.unwrap_or_default(),
6192 stream_key: stream_key__.unwrap_or_default(),
6193 use_current_epoch: use_current_epoch__.unwrap_or_default(),
6194 column_mapping: column_mapping__.unwrap_or_default(),
6195 arrangement_table_info: arrangement_table_info__,
6196 arrangement_table_id: arrangement_table_id__,
6197 })
6198 }
6199 }
6200 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6201 }
6202}
6203impl serde::Serialize for LookupUnionNode {
6204 #[allow(deprecated)]
6205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6206 where
6207 S: serde::Serializer,
6208 {
6209 use serde::ser::SerializeStruct;
6210 let mut len = 0;
6211 if !self.order.is_empty() {
6212 len += 1;
6213 }
6214 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6215 if !self.order.is_empty() {
6216 struct_ser.serialize_field("order", &self.order)?;
6217 }
6218 struct_ser.end()
6219 }
6220}
6221impl<'de> serde::Deserialize<'de> for LookupUnionNode {
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 "order",
6229 ];
6230
6231 #[allow(clippy::enum_variant_names)]
6232 enum GeneratedField {
6233 Order,
6234 }
6235 impl<'de> serde::Deserialize<'de> for GeneratedField {
6236 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6237 where
6238 D: serde::Deserializer<'de>,
6239 {
6240 struct GeneratedVisitor;
6241
6242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6243 type Value = GeneratedField;
6244
6245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6246 write!(formatter, "expected one of: {:?}", &FIELDS)
6247 }
6248
6249 #[allow(unused_variables)]
6250 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6251 where
6252 E: serde::de::Error,
6253 {
6254 match value {
6255 "order" => Ok(GeneratedField::Order),
6256 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6257 }
6258 }
6259 }
6260 deserializer.deserialize_identifier(GeneratedVisitor)
6261 }
6262 }
6263 struct GeneratedVisitor;
6264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6265 type Value = LookupUnionNode;
6266
6267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6268 formatter.write_str("struct stream_plan.LookupUnionNode")
6269 }
6270
6271 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6272 where
6273 V: serde::de::MapAccess<'de>,
6274 {
6275 let mut order__ = None;
6276 while let Some(k) = map_.next_key()? {
6277 match k {
6278 GeneratedField::Order => {
6279 if order__.is_some() {
6280 return Err(serde::de::Error::duplicate_field("order"));
6281 }
6282 order__ =
6283 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6284 .into_iter().map(|x| x.0).collect())
6285 ;
6286 }
6287 }
6288 }
6289 Ok(LookupUnionNode {
6290 order: order__.unwrap_or_default(),
6291 })
6292 }
6293 }
6294 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6295 }
6296}
6297impl serde::Serialize for MaterializeNode {
6298 #[allow(deprecated)]
6299 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6300 where
6301 S: serde::Serializer,
6302 {
6303 use serde::ser::SerializeStruct;
6304 let mut len = 0;
6305 if self.table_id != 0 {
6306 len += 1;
6307 }
6308 if !self.column_orders.is_empty() {
6309 len += 1;
6310 }
6311 if self.table.is_some() {
6312 len += 1;
6313 }
6314 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6315 if self.table_id != 0 {
6316 struct_ser.serialize_field("tableId", &self.table_id)?;
6317 }
6318 if !self.column_orders.is_empty() {
6319 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6320 }
6321 if let Some(v) = self.table.as_ref() {
6322 struct_ser.serialize_field("table", v)?;
6323 }
6324 struct_ser.end()
6325 }
6326}
6327impl<'de> serde::Deserialize<'de> for MaterializeNode {
6328 #[allow(deprecated)]
6329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6330 where
6331 D: serde::Deserializer<'de>,
6332 {
6333 const FIELDS: &[&str] = &[
6334 "table_id",
6335 "tableId",
6336 "column_orders",
6337 "columnOrders",
6338 "table",
6339 ];
6340
6341 #[allow(clippy::enum_variant_names)]
6342 enum GeneratedField {
6343 TableId,
6344 ColumnOrders,
6345 Table,
6346 }
6347 impl<'de> serde::Deserialize<'de> for GeneratedField {
6348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6349 where
6350 D: serde::Deserializer<'de>,
6351 {
6352 struct GeneratedVisitor;
6353
6354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6355 type Value = GeneratedField;
6356
6357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6358 write!(formatter, "expected one of: {:?}", &FIELDS)
6359 }
6360
6361 #[allow(unused_variables)]
6362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6363 where
6364 E: serde::de::Error,
6365 {
6366 match value {
6367 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6368 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6369 "table" => Ok(GeneratedField::Table),
6370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6371 }
6372 }
6373 }
6374 deserializer.deserialize_identifier(GeneratedVisitor)
6375 }
6376 }
6377 struct GeneratedVisitor;
6378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6379 type Value = MaterializeNode;
6380
6381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6382 formatter.write_str("struct stream_plan.MaterializeNode")
6383 }
6384
6385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6386 where
6387 V: serde::de::MapAccess<'de>,
6388 {
6389 let mut table_id__ = None;
6390 let mut column_orders__ = None;
6391 let mut table__ = None;
6392 while let Some(k) = map_.next_key()? {
6393 match k {
6394 GeneratedField::TableId => {
6395 if table_id__.is_some() {
6396 return Err(serde::de::Error::duplicate_field("tableId"));
6397 }
6398 table_id__ =
6399 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6400 ;
6401 }
6402 GeneratedField::ColumnOrders => {
6403 if column_orders__.is_some() {
6404 return Err(serde::de::Error::duplicate_field("columnOrders"));
6405 }
6406 column_orders__ = Some(map_.next_value()?);
6407 }
6408 GeneratedField::Table => {
6409 if table__.is_some() {
6410 return Err(serde::de::Error::duplicate_field("table"));
6411 }
6412 table__ = map_.next_value()?;
6413 }
6414 }
6415 }
6416 Ok(MaterializeNode {
6417 table_id: table_id__.unwrap_or_default(),
6418 column_orders: column_orders__.unwrap_or_default(),
6419 table: table__,
6420 })
6421 }
6422 }
6423 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6424 }
6425}
6426impl serde::Serialize for MaterializedExprsNode {
6427 #[allow(deprecated)]
6428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6429 where
6430 S: serde::Serializer,
6431 {
6432 use serde::ser::SerializeStruct;
6433 let mut len = 0;
6434 if !self.exprs.is_empty() {
6435 len += 1;
6436 }
6437 if self.state_table.is_some() {
6438 len += 1;
6439 }
6440 if self.state_clean_col_idx.is_some() {
6441 len += 1;
6442 }
6443 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6444 if !self.exprs.is_empty() {
6445 struct_ser.serialize_field("exprs", &self.exprs)?;
6446 }
6447 if let Some(v) = self.state_table.as_ref() {
6448 struct_ser.serialize_field("stateTable", v)?;
6449 }
6450 if let Some(v) = self.state_clean_col_idx.as_ref() {
6451 struct_ser.serialize_field("stateCleanColIdx", v)?;
6452 }
6453 struct_ser.end()
6454 }
6455}
6456impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6457 #[allow(deprecated)]
6458 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6459 where
6460 D: serde::Deserializer<'de>,
6461 {
6462 const FIELDS: &[&str] = &[
6463 "exprs",
6464 "state_table",
6465 "stateTable",
6466 "state_clean_col_idx",
6467 "stateCleanColIdx",
6468 ];
6469
6470 #[allow(clippy::enum_variant_names)]
6471 enum GeneratedField {
6472 Exprs,
6473 StateTable,
6474 StateCleanColIdx,
6475 }
6476 impl<'de> serde::Deserialize<'de> for GeneratedField {
6477 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6478 where
6479 D: serde::Deserializer<'de>,
6480 {
6481 struct GeneratedVisitor;
6482
6483 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6484 type Value = GeneratedField;
6485
6486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6487 write!(formatter, "expected one of: {:?}", &FIELDS)
6488 }
6489
6490 #[allow(unused_variables)]
6491 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6492 where
6493 E: serde::de::Error,
6494 {
6495 match value {
6496 "exprs" => Ok(GeneratedField::Exprs),
6497 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6498 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
6499 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6500 }
6501 }
6502 }
6503 deserializer.deserialize_identifier(GeneratedVisitor)
6504 }
6505 }
6506 struct GeneratedVisitor;
6507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6508 type Value = MaterializedExprsNode;
6509
6510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6511 formatter.write_str("struct stream_plan.MaterializedExprsNode")
6512 }
6513
6514 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6515 where
6516 V: serde::de::MapAccess<'de>,
6517 {
6518 let mut exprs__ = None;
6519 let mut state_table__ = None;
6520 let mut state_clean_col_idx__ = None;
6521 while let Some(k) = map_.next_key()? {
6522 match k {
6523 GeneratedField::Exprs => {
6524 if exprs__.is_some() {
6525 return Err(serde::de::Error::duplicate_field("exprs"));
6526 }
6527 exprs__ = Some(map_.next_value()?);
6528 }
6529 GeneratedField::StateTable => {
6530 if state_table__.is_some() {
6531 return Err(serde::de::Error::duplicate_field("stateTable"));
6532 }
6533 state_table__ = map_.next_value()?;
6534 }
6535 GeneratedField::StateCleanColIdx => {
6536 if state_clean_col_idx__.is_some() {
6537 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6538 }
6539 state_clean_col_idx__ =
6540 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6541 ;
6542 }
6543 }
6544 }
6545 Ok(MaterializedExprsNode {
6546 exprs: exprs__.unwrap_or_default(),
6547 state_table: state_table__,
6548 state_clean_col_idx: state_clean_col_idx__,
6549 })
6550 }
6551 }
6552 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6553 }
6554}
6555impl serde::Serialize for MergeNode {
6556 #[allow(deprecated)]
6557 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6558 where
6559 S: serde::Serializer,
6560 {
6561 use serde::ser::SerializeStruct;
6562 let mut len = 0;
6563 if !self.upstream_actor_id.is_empty() {
6564 len += 1;
6565 }
6566 if self.upstream_fragment_id != 0 {
6567 len += 1;
6568 }
6569 if self.upstream_dispatcher_type != 0 {
6570 len += 1;
6571 }
6572 if !self.fields.is_empty() {
6573 len += 1;
6574 }
6575 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
6576 if !self.upstream_actor_id.is_empty() {
6577 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
6578 }
6579 if self.upstream_fragment_id != 0 {
6580 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
6581 }
6582 if self.upstream_dispatcher_type != 0 {
6583 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
6584 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
6585 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
6586 }
6587 if !self.fields.is_empty() {
6588 struct_ser.serialize_field("fields", &self.fields)?;
6589 }
6590 struct_ser.end()
6591 }
6592}
6593impl<'de> serde::Deserialize<'de> for MergeNode {
6594 #[allow(deprecated)]
6595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6596 where
6597 D: serde::Deserializer<'de>,
6598 {
6599 const FIELDS: &[&str] = &[
6600 "upstream_actor_id",
6601 "upstreamActorId",
6602 "upstream_fragment_id",
6603 "upstreamFragmentId",
6604 "upstream_dispatcher_type",
6605 "upstreamDispatcherType",
6606 "fields",
6607 ];
6608
6609 #[allow(clippy::enum_variant_names)]
6610 enum GeneratedField {
6611 UpstreamActorId,
6612 UpstreamFragmentId,
6613 UpstreamDispatcherType,
6614 Fields,
6615 }
6616 impl<'de> serde::Deserialize<'de> for GeneratedField {
6617 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6618 where
6619 D: serde::Deserializer<'de>,
6620 {
6621 struct GeneratedVisitor;
6622
6623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6624 type Value = GeneratedField;
6625
6626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6627 write!(formatter, "expected one of: {:?}", &FIELDS)
6628 }
6629
6630 #[allow(unused_variables)]
6631 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6632 where
6633 E: serde::de::Error,
6634 {
6635 match value {
6636 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
6637 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
6638 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
6639 "fields" => Ok(GeneratedField::Fields),
6640 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6641 }
6642 }
6643 }
6644 deserializer.deserialize_identifier(GeneratedVisitor)
6645 }
6646 }
6647 struct GeneratedVisitor;
6648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6649 type Value = MergeNode;
6650
6651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6652 formatter.write_str("struct stream_plan.MergeNode")
6653 }
6654
6655 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
6656 where
6657 V: serde::de::MapAccess<'de>,
6658 {
6659 let mut upstream_actor_id__ = None;
6660 let mut upstream_fragment_id__ = None;
6661 let mut upstream_dispatcher_type__ = None;
6662 let mut fields__ = None;
6663 while let Some(k) = map_.next_key()? {
6664 match k {
6665 GeneratedField::UpstreamActorId => {
6666 if upstream_actor_id__.is_some() {
6667 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
6668 }
6669 upstream_actor_id__ =
6670 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6671 .into_iter().map(|x| x.0).collect())
6672 ;
6673 }
6674 GeneratedField::UpstreamFragmentId => {
6675 if upstream_fragment_id__.is_some() {
6676 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
6677 }
6678 upstream_fragment_id__ =
6679 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6680 ;
6681 }
6682 GeneratedField::UpstreamDispatcherType => {
6683 if upstream_dispatcher_type__.is_some() {
6684 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
6685 }
6686 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
6687 }
6688 GeneratedField::Fields => {
6689 if fields__.is_some() {
6690 return Err(serde::de::Error::duplicate_field("fields"));
6691 }
6692 fields__ = Some(map_.next_value()?);
6693 }
6694 }
6695 }
6696 Ok(MergeNode {
6697 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
6698 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
6699 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
6700 fields: fields__.unwrap_or_default(),
6701 })
6702 }
6703 }
6704 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
6705 }
6706}
6707impl serde::Serialize for NoOpNode {
6708 #[allow(deprecated)]
6709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6710 where
6711 S: serde::Serializer,
6712 {
6713 use serde::ser::SerializeStruct;
6714 let len = 0;
6715 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
6716 struct_ser.end()
6717 }
6718}
6719impl<'de> serde::Deserialize<'de> for NoOpNode {
6720 #[allow(deprecated)]
6721 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6722 where
6723 D: serde::Deserializer<'de>,
6724 {
6725 const FIELDS: &[&str] = &[
6726 ];
6727
6728 #[allow(clippy::enum_variant_names)]
6729 enum GeneratedField {
6730 }
6731 impl<'de> serde::Deserialize<'de> for GeneratedField {
6732 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6733 where
6734 D: serde::Deserializer<'de>,
6735 {
6736 struct GeneratedVisitor;
6737
6738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6739 type Value = GeneratedField;
6740
6741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6742 write!(formatter, "expected one of: {:?}", &FIELDS)
6743 }
6744
6745 #[allow(unused_variables)]
6746 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6747 where
6748 E: serde::de::Error,
6749 {
6750 Err(serde::de::Error::unknown_field(value, FIELDS))
6751 }
6752 }
6753 deserializer.deserialize_identifier(GeneratedVisitor)
6754 }
6755 }
6756 struct GeneratedVisitor;
6757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6758 type Value = NoOpNode;
6759
6760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6761 formatter.write_str("struct stream_plan.NoOpNode")
6762 }
6763
6764 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
6765 where
6766 V: serde::de::MapAccess<'de>,
6767 {
6768 while map_.next_key::<GeneratedField>()?.is_some() {
6769 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6770 }
6771 Ok(NoOpNode {
6772 })
6773 }
6774 }
6775 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
6776 }
6777}
6778impl serde::Serialize for NowModeGenerateSeries {
6779 #[allow(deprecated)]
6780 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6781 where
6782 S: serde::Serializer,
6783 {
6784 use serde::ser::SerializeStruct;
6785 let mut len = 0;
6786 if self.start_timestamp.is_some() {
6787 len += 1;
6788 }
6789 if self.interval.is_some() {
6790 len += 1;
6791 }
6792 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
6793 if let Some(v) = self.start_timestamp.as_ref() {
6794 struct_ser.serialize_field("startTimestamp", v)?;
6795 }
6796 if let Some(v) = self.interval.as_ref() {
6797 struct_ser.serialize_field("interval", v)?;
6798 }
6799 struct_ser.end()
6800 }
6801}
6802impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
6803 #[allow(deprecated)]
6804 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6805 where
6806 D: serde::Deserializer<'de>,
6807 {
6808 const FIELDS: &[&str] = &[
6809 "start_timestamp",
6810 "startTimestamp",
6811 "interval",
6812 ];
6813
6814 #[allow(clippy::enum_variant_names)]
6815 enum GeneratedField {
6816 StartTimestamp,
6817 Interval,
6818 }
6819 impl<'de> serde::Deserialize<'de> for GeneratedField {
6820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6821 where
6822 D: serde::Deserializer<'de>,
6823 {
6824 struct GeneratedVisitor;
6825
6826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6827 type Value = GeneratedField;
6828
6829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6830 write!(formatter, "expected one of: {:?}", &FIELDS)
6831 }
6832
6833 #[allow(unused_variables)]
6834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6835 where
6836 E: serde::de::Error,
6837 {
6838 match value {
6839 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
6840 "interval" => Ok(GeneratedField::Interval),
6841 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6842 }
6843 }
6844 }
6845 deserializer.deserialize_identifier(GeneratedVisitor)
6846 }
6847 }
6848 struct GeneratedVisitor;
6849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6850 type Value = NowModeGenerateSeries;
6851
6852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6853 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
6854 }
6855
6856 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
6857 where
6858 V: serde::de::MapAccess<'de>,
6859 {
6860 let mut start_timestamp__ = None;
6861 let mut interval__ = None;
6862 while let Some(k) = map_.next_key()? {
6863 match k {
6864 GeneratedField::StartTimestamp => {
6865 if start_timestamp__.is_some() {
6866 return Err(serde::de::Error::duplicate_field("startTimestamp"));
6867 }
6868 start_timestamp__ = map_.next_value()?;
6869 }
6870 GeneratedField::Interval => {
6871 if interval__.is_some() {
6872 return Err(serde::de::Error::duplicate_field("interval"));
6873 }
6874 interval__ = map_.next_value()?;
6875 }
6876 }
6877 }
6878 Ok(NowModeGenerateSeries {
6879 start_timestamp: start_timestamp__,
6880 interval: interval__,
6881 })
6882 }
6883 }
6884 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
6885 }
6886}
6887impl serde::Serialize for NowModeUpdateCurrent {
6888 #[allow(deprecated)]
6889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6890 where
6891 S: serde::Serializer,
6892 {
6893 use serde::ser::SerializeStruct;
6894 let len = 0;
6895 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
6896 struct_ser.end()
6897 }
6898}
6899impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
6900 #[allow(deprecated)]
6901 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6902 where
6903 D: serde::Deserializer<'de>,
6904 {
6905 const FIELDS: &[&str] = &[
6906 ];
6907
6908 #[allow(clippy::enum_variant_names)]
6909 enum GeneratedField {
6910 }
6911 impl<'de> serde::Deserialize<'de> for GeneratedField {
6912 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6913 where
6914 D: serde::Deserializer<'de>,
6915 {
6916 struct GeneratedVisitor;
6917
6918 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6919 type Value = GeneratedField;
6920
6921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6922 write!(formatter, "expected one of: {:?}", &FIELDS)
6923 }
6924
6925 #[allow(unused_variables)]
6926 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6927 where
6928 E: serde::de::Error,
6929 {
6930 Err(serde::de::Error::unknown_field(value, FIELDS))
6931 }
6932 }
6933 deserializer.deserialize_identifier(GeneratedVisitor)
6934 }
6935 }
6936 struct GeneratedVisitor;
6937 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6938 type Value = NowModeUpdateCurrent;
6939
6940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6941 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
6942 }
6943
6944 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
6945 where
6946 V: serde::de::MapAccess<'de>,
6947 {
6948 while map_.next_key::<GeneratedField>()?.is_some() {
6949 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6950 }
6951 Ok(NowModeUpdateCurrent {
6952 })
6953 }
6954 }
6955 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
6956 }
6957}
6958impl serde::Serialize for NowNode {
6959 #[allow(deprecated)]
6960 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6961 where
6962 S: serde::Serializer,
6963 {
6964 use serde::ser::SerializeStruct;
6965 let mut len = 0;
6966 if self.state_table.is_some() {
6967 len += 1;
6968 }
6969 if self.mode.is_some() {
6970 len += 1;
6971 }
6972 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
6973 if let Some(v) = self.state_table.as_ref() {
6974 struct_ser.serialize_field("stateTable", v)?;
6975 }
6976 if let Some(v) = self.mode.as_ref() {
6977 match v {
6978 now_node::Mode::UpdateCurrent(v) => {
6979 struct_ser.serialize_field("updateCurrent", v)?;
6980 }
6981 now_node::Mode::GenerateSeries(v) => {
6982 struct_ser.serialize_field("generateSeries", v)?;
6983 }
6984 }
6985 }
6986 struct_ser.end()
6987 }
6988}
6989impl<'de> serde::Deserialize<'de> for NowNode {
6990 #[allow(deprecated)]
6991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6992 where
6993 D: serde::Deserializer<'de>,
6994 {
6995 const FIELDS: &[&str] = &[
6996 "state_table",
6997 "stateTable",
6998 "update_current",
6999 "updateCurrent",
7000 "generate_series",
7001 "generateSeries",
7002 ];
7003
7004 #[allow(clippy::enum_variant_names)]
7005 enum GeneratedField {
7006 StateTable,
7007 UpdateCurrent,
7008 GenerateSeries,
7009 }
7010 impl<'de> serde::Deserialize<'de> for GeneratedField {
7011 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7012 where
7013 D: serde::Deserializer<'de>,
7014 {
7015 struct GeneratedVisitor;
7016
7017 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7018 type Value = GeneratedField;
7019
7020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7021 write!(formatter, "expected one of: {:?}", &FIELDS)
7022 }
7023
7024 #[allow(unused_variables)]
7025 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7026 where
7027 E: serde::de::Error,
7028 {
7029 match value {
7030 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7031 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7032 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7034 }
7035 }
7036 }
7037 deserializer.deserialize_identifier(GeneratedVisitor)
7038 }
7039 }
7040 struct GeneratedVisitor;
7041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7042 type Value = NowNode;
7043
7044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7045 formatter.write_str("struct stream_plan.NowNode")
7046 }
7047
7048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7049 where
7050 V: serde::de::MapAccess<'de>,
7051 {
7052 let mut state_table__ = None;
7053 let mut mode__ = None;
7054 while let Some(k) = map_.next_key()? {
7055 match k {
7056 GeneratedField::StateTable => {
7057 if state_table__.is_some() {
7058 return Err(serde::de::Error::duplicate_field("stateTable"));
7059 }
7060 state_table__ = map_.next_value()?;
7061 }
7062 GeneratedField::UpdateCurrent => {
7063 if mode__.is_some() {
7064 return Err(serde::de::Error::duplicate_field("updateCurrent"));
7065 }
7066 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7067;
7068 }
7069 GeneratedField::GenerateSeries => {
7070 if mode__.is_some() {
7071 return Err(serde::de::Error::duplicate_field("generateSeries"));
7072 }
7073 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7074;
7075 }
7076 }
7077 }
7078 Ok(NowNode {
7079 state_table: state_table__,
7080 mode: mode__,
7081 })
7082 }
7083 }
7084 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7085 }
7086}
7087impl serde::Serialize for OverWindowCachePolicy {
7088 #[allow(deprecated)]
7089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7090 where
7091 S: serde::Serializer,
7092 {
7093 let variant = match self {
7094 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7095 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7096 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7097 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7098 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7099 };
7100 serializer.serialize_str(variant)
7101 }
7102}
7103impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7104 #[allow(deprecated)]
7105 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7106 where
7107 D: serde::Deserializer<'de>,
7108 {
7109 const FIELDS: &[&str] = &[
7110 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7111 "OVER_WINDOW_CACHE_POLICY_FULL",
7112 "OVER_WINDOW_CACHE_POLICY_RECENT",
7113 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7114 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7115 ];
7116
7117 struct GeneratedVisitor;
7118
7119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7120 type Value = OverWindowCachePolicy;
7121
7122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7123 write!(formatter, "expected one of: {:?}", &FIELDS)
7124 }
7125
7126 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7127 where
7128 E: serde::de::Error,
7129 {
7130 i32::try_from(v)
7131 .ok()
7132 .and_then(|x| x.try_into().ok())
7133 .ok_or_else(|| {
7134 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7135 })
7136 }
7137
7138 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7139 where
7140 E: serde::de::Error,
7141 {
7142 i32::try_from(v)
7143 .ok()
7144 .and_then(|x| x.try_into().ok())
7145 .ok_or_else(|| {
7146 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7147 })
7148 }
7149
7150 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7151 where
7152 E: serde::de::Error,
7153 {
7154 match value {
7155 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7156 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7157 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7158 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7159 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7160 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7161 }
7162 }
7163 }
7164 deserializer.deserialize_any(GeneratedVisitor)
7165 }
7166}
7167impl serde::Serialize for OverWindowNode {
7168 #[allow(deprecated)]
7169 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7170 where
7171 S: serde::Serializer,
7172 {
7173 use serde::ser::SerializeStruct;
7174 let mut len = 0;
7175 if !self.calls.is_empty() {
7176 len += 1;
7177 }
7178 if !self.partition_by.is_empty() {
7179 len += 1;
7180 }
7181 if !self.order_by.is_empty() {
7182 len += 1;
7183 }
7184 if self.state_table.is_some() {
7185 len += 1;
7186 }
7187 if self.cache_policy != 0 {
7188 len += 1;
7189 }
7190 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7191 if !self.calls.is_empty() {
7192 struct_ser.serialize_field("calls", &self.calls)?;
7193 }
7194 if !self.partition_by.is_empty() {
7195 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7196 }
7197 if !self.order_by.is_empty() {
7198 struct_ser.serialize_field("orderBy", &self.order_by)?;
7199 }
7200 if let Some(v) = self.state_table.as_ref() {
7201 struct_ser.serialize_field("stateTable", v)?;
7202 }
7203 if self.cache_policy != 0 {
7204 let v = OverWindowCachePolicy::try_from(self.cache_policy)
7205 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7206 struct_ser.serialize_field("cachePolicy", &v)?;
7207 }
7208 struct_ser.end()
7209 }
7210}
7211impl<'de> serde::Deserialize<'de> for OverWindowNode {
7212 #[allow(deprecated)]
7213 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7214 where
7215 D: serde::Deserializer<'de>,
7216 {
7217 const FIELDS: &[&str] = &[
7218 "calls",
7219 "partition_by",
7220 "partitionBy",
7221 "order_by",
7222 "orderBy",
7223 "state_table",
7224 "stateTable",
7225 "cache_policy",
7226 "cachePolicy",
7227 ];
7228
7229 #[allow(clippy::enum_variant_names)]
7230 enum GeneratedField {
7231 Calls,
7232 PartitionBy,
7233 OrderBy,
7234 StateTable,
7235 CachePolicy,
7236 }
7237 impl<'de> serde::Deserialize<'de> for GeneratedField {
7238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7239 where
7240 D: serde::Deserializer<'de>,
7241 {
7242 struct GeneratedVisitor;
7243
7244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7245 type Value = GeneratedField;
7246
7247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7248 write!(formatter, "expected one of: {:?}", &FIELDS)
7249 }
7250
7251 #[allow(unused_variables)]
7252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7253 where
7254 E: serde::de::Error,
7255 {
7256 match value {
7257 "calls" => Ok(GeneratedField::Calls),
7258 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7259 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7260 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7261 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7262 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7263 }
7264 }
7265 }
7266 deserializer.deserialize_identifier(GeneratedVisitor)
7267 }
7268 }
7269 struct GeneratedVisitor;
7270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7271 type Value = OverWindowNode;
7272
7273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7274 formatter.write_str("struct stream_plan.OverWindowNode")
7275 }
7276
7277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7278 where
7279 V: serde::de::MapAccess<'de>,
7280 {
7281 let mut calls__ = None;
7282 let mut partition_by__ = None;
7283 let mut order_by__ = None;
7284 let mut state_table__ = None;
7285 let mut cache_policy__ = None;
7286 while let Some(k) = map_.next_key()? {
7287 match k {
7288 GeneratedField::Calls => {
7289 if calls__.is_some() {
7290 return Err(serde::de::Error::duplicate_field("calls"));
7291 }
7292 calls__ = Some(map_.next_value()?);
7293 }
7294 GeneratedField::PartitionBy => {
7295 if partition_by__.is_some() {
7296 return Err(serde::de::Error::duplicate_field("partitionBy"));
7297 }
7298 partition_by__ =
7299 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7300 .into_iter().map(|x| x.0).collect())
7301 ;
7302 }
7303 GeneratedField::OrderBy => {
7304 if order_by__.is_some() {
7305 return Err(serde::de::Error::duplicate_field("orderBy"));
7306 }
7307 order_by__ = Some(map_.next_value()?);
7308 }
7309 GeneratedField::StateTable => {
7310 if state_table__.is_some() {
7311 return Err(serde::de::Error::duplicate_field("stateTable"));
7312 }
7313 state_table__ = map_.next_value()?;
7314 }
7315 GeneratedField::CachePolicy => {
7316 if cache_policy__.is_some() {
7317 return Err(serde::de::Error::duplicate_field("cachePolicy"));
7318 }
7319 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7320 }
7321 }
7322 }
7323 Ok(OverWindowNode {
7324 calls: calls__.unwrap_or_default(),
7325 partition_by: partition_by__.unwrap_or_default(),
7326 order_by: order_by__.unwrap_or_default(),
7327 state_table: state_table__,
7328 cache_policy: cache_policy__.unwrap_or_default(),
7329 })
7330 }
7331 }
7332 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7333 }
7334}
7335impl serde::Serialize for PauseMutation {
7336 #[allow(deprecated)]
7337 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7338 where
7339 S: serde::Serializer,
7340 {
7341 use serde::ser::SerializeStruct;
7342 let len = 0;
7343 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7344 struct_ser.end()
7345 }
7346}
7347impl<'de> serde::Deserialize<'de> for PauseMutation {
7348 #[allow(deprecated)]
7349 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7350 where
7351 D: serde::Deserializer<'de>,
7352 {
7353 const FIELDS: &[&str] = &[
7354 ];
7355
7356 #[allow(clippy::enum_variant_names)]
7357 enum GeneratedField {
7358 }
7359 impl<'de> serde::Deserialize<'de> for GeneratedField {
7360 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7361 where
7362 D: serde::Deserializer<'de>,
7363 {
7364 struct GeneratedVisitor;
7365
7366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7367 type Value = GeneratedField;
7368
7369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7370 write!(formatter, "expected one of: {:?}", &FIELDS)
7371 }
7372
7373 #[allow(unused_variables)]
7374 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7375 where
7376 E: serde::de::Error,
7377 {
7378 Err(serde::de::Error::unknown_field(value, FIELDS))
7379 }
7380 }
7381 deserializer.deserialize_identifier(GeneratedVisitor)
7382 }
7383 }
7384 struct GeneratedVisitor;
7385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7386 type Value = PauseMutation;
7387
7388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7389 formatter.write_str("struct stream_plan.PauseMutation")
7390 }
7391
7392 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7393 where
7394 V: serde::de::MapAccess<'de>,
7395 {
7396 while map_.next_key::<GeneratedField>()?.is_some() {
7397 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7398 }
7399 Ok(PauseMutation {
7400 })
7401 }
7402 }
7403 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7404 }
7405}
7406impl serde::Serialize for ProjectNode {
7407 #[allow(deprecated)]
7408 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7409 where
7410 S: serde::Serializer,
7411 {
7412 use serde::ser::SerializeStruct;
7413 let mut len = 0;
7414 if !self.select_list.is_empty() {
7415 len += 1;
7416 }
7417 if !self.watermark_input_cols.is_empty() {
7418 len += 1;
7419 }
7420 if !self.watermark_output_cols.is_empty() {
7421 len += 1;
7422 }
7423 if !self.nondecreasing_exprs.is_empty() {
7424 len += 1;
7425 }
7426 if self.noop_update_hint {
7427 len += 1;
7428 }
7429 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7430 if !self.select_list.is_empty() {
7431 struct_ser.serialize_field("selectList", &self.select_list)?;
7432 }
7433 if !self.watermark_input_cols.is_empty() {
7434 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7435 }
7436 if !self.watermark_output_cols.is_empty() {
7437 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7438 }
7439 if !self.nondecreasing_exprs.is_empty() {
7440 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7441 }
7442 if self.noop_update_hint {
7443 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7444 }
7445 struct_ser.end()
7446 }
7447}
7448impl<'de> serde::Deserialize<'de> for ProjectNode {
7449 #[allow(deprecated)]
7450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7451 where
7452 D: serde::Deserializer<'de>,
7453 {
7454 const FIELDS: &[&str] = &[
7455 "select_list",
7456 "selectList",
7457 "watermark_input_cols",
7458 "watermarkInputCols",
7459 "watermark_output_cols",
7460 "watermarkOutputCols",
7461 "nondecreasing_exprs",
7462 "nondecreasingExprs",
7463 "noop_update_hint",
7464 "noopUpdateHint",
7465 ];
7466
7467 #[allow(clippy::enum_variant_names)]
7468 enum GeneratedField {
7469 SelectList,
7470 WatermarkInputCols,
7471 WatermarkOutputCols,
7472 NondecreasingExprs,
7473 NoopUpdateHint,
7474 }
7475 impl<'de> serde::Deserialize<'de> for GeneratedField {
7476 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7477 where
7478 D: serde::Deserializer<'de>,
7479 {
7480 struct GeneratedVisitor;
7481
7482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7483 type Value = GeneratedField;
7484
7485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7486 write!(formatter, "expected one of: {:?}", &FIELDS)
7487 }
7488
7489 #[allow(unused_variables)]
7490 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7491 where
7492 E: serde::de::Error,
7493 {
7494 match value {
7495 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7496 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7497 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7498 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7499 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7501 }
7502 }
7503 }
7504 deserializer.deserialize_identifier(GeneratedVisitor)
7505 }
7506 }
7507 struct GeneratedVisitor;
7508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7509 type Value = ProjectNode;
7510
7511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7512 formatter.write_str("struct stream_plan.ProjectNode")
7513 }
7514
7515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7516 where
7517 V: serde::de::MapAccess<'de>,
7518 {
7519 let mut select_list__ = None;
7520 let mut watermark_input_cols__ = None;
7521 let mut watermark_output_cols__ = None;
7522 let mut nondecreasing_exprs__ = None;
7523 let mut noop_update_hint__ = None;
7524 while let Some(k) = map_.next_key()? {
7525 match k {
7526 GeneratedField::SelectList => {
7527 if select_list__.is_some() {
7528 return Err(serde::de::Error::duplicate_field("selectList"));
7529 }
7530 select_list__ = Some(map_.next_value()?);
7531 }
7532 GeneratedField::WatermarkInputCols => {
7533 if watermark_input_cols__.is_some() {
7534 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7535 }
7536 watermark_input_cols__ =
7537 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7538 .into_iter().map(|x| x.0).collect())
7539 ;
7540 }
7541 GeneratedField::WatermarkOutputCols => {
7542 if watermark_output_cols__.is_some() {
7543 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7544 }
7545 watermark_output_cols__ =
7546 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7547 .into_iter().map(|x| x.0).collect())
7548 ;
7549 }
7550 GeneratedField::NondecreasingExprs => {
7551 if nondecreasing_exprs__.is_some() {
7552 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7553 }
7554 nondecreasing_exprs__ =
7555 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7556 .into_iter().map(|x| x.0).collect())
7557 ;
7558 }
7559 GeneratedField::NoopUpdateHint => {
7560 if noop_update_hint__.is_some() {
7561 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
7562 }
7563 noop_update_hint__ = Some(map_.next_value()?);
7564 }
7565 }
7566 }
7567 Ok(ProjectNode {
7568 select_list: select_list__.unwrap_or_default(),
7569 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7570 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
7571 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7572 noop_update_hint: noop_update_hint__.unwrap_or_default(),
7573 })
7574 }
7575 }
7576 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
7577 }
7578}
7579impl serde::Serialize for ProjectSetNode {
7580 #[allow(deprecated)]
7581 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7582 where
7583 S: serde::Serializer,
7584 {
7585 use serde::ser::SerializeStruct;
7586 let mut len = 0;
7587 if !self.select_list.is_empty() {
7588 len += 1;
7589 }
7590 if !self.watermark_input_cols.is_empty() {
7591 len += 1;
7592 }
7593 if !self.watermark_expr_indices.is_empty() {
7594 len += 1;
7595 }
7596 if !self.nondecreasing_exprs.is_empty() {
7597 len += 1;
7598 }
7599 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
7600 if !self.select_list.is_empty() {
7601 struct_ser.serialize_field("selectList", &self.select_list)?;
7602 }
7603 if !self.watermark_input_cols.is_empty() {
7604 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7605 }
7606 if !self.watermark_expr_indices.is_empty() {
7607 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
7608 }
7609 if !self.nondecreasing_exprs.is_empty() {
7610 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7611 }
7612 struct_ser.end()
7613 }
7614}
7615impl<'de> serde::Deserialize<'de> for ProjectSetNode {
7616 #[allow(deprecated)]
7617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7618 where
7619 D: serde::Deserializer<'de>,
7620 {
7621 const FIELDS: &[&str] = &[
7622 "select_list",
7623 "selectList",
7624 "watermark_input_cols",
7625 "watermarkInputCols",
7626 "watermark_expr_indices",
7627 "watermarkExprIndices",
7628 "nondecreasing_exprs",
7629 "nondecreasingExprs",
7630 ];
7631
7632 #[allow(clippy::enum_variant_names)]
7633 enum GeneratedField {
7634 SelectList,
7635 WatermarkInputCols,
7636 WatermarkExprIndices,
7637 NondecreasingExprs,
7638 }
7639 impl<'de> serde::Deserialize<'de> for GeneratedField {
7640 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7641 where
7642 D: serde::Deserializer<'de>,
7643 {
7644 struct GeneratedVisitor;
7645
7646 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7647 type Value = GeneratedField;
7648
7649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7650 write!(formatter, "expected one of: {:?}", &FIELDS)
7651 }
7652
7653 #[allow(unused_variables)]
7654 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7655 where
7656 E: serde::de::Error,
7657 {
7658 match value {
7659 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7660 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7661 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
7662 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7664 }
7665 }
7666 }
7667 deserializer.deserialize_identifier(GeneratedVisitor)
7668 }
7669 }
7670 struct GeneratedVisitor;
7671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7672 type Value = ProjectSetNode;
7673
7674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7675 formatter.write_str("struct stream_plan.ProjectSetNode")
7676 }
7677
7678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
7679 where
7680 V: serde::de::MapAccess<'de>,
7681 {
7682 let mut select_list__ = None;
7683 let mut watermark_input_cols__ = None;
7684 let mut watermark_expr_indices__ = None;
7685 let mut nondecreasing_exprs__ = None;
7686 while let Some(k) = map_.next_key()? {
7687 match k {
7688 GeneratedField::SelectList => {
7689 if select_list__.is_some() {
7690 return Err(serde::de::Error::duplicate_field("selectList"));
7691 }
7692 select_list__ = Some(map_.next_value()?);
7693 }
7694 GeneratedField::WatermarkInputCols => {
7695 if watermark_input_cols__.is_some() {
7696 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7697 }
7698 watermark_input_cols__ =
7699 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7700 .into_iter().map(|x| x.0).collect())
7701 ;
7702 }
7703 GeneratedField::WatermarkExprIndices => {
7704 if watermark_expr_indices__.is_some() {
7705 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
7706 }
7707 watermark_expr_indices__ =
7708 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7709 .into_iter().map(|x| x.0).collect())
7710 ;
7711 }
7712 GeneratedField::NondecreasingExprs => {
7713 if nondecreasing_exprs__.is_some() {
7714 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7715 }
7716 nondecreasing_exprs__ =
7717 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7718 .into_iter().map(|x| x.0).collect())
7719 ;
7720 }
7721 }
7722 }
7723 Ok(ProjectSetNode {
7724 select_list: select_list__.unwrap_or_default(),
7725 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7726 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
7727 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7728 })
7729 }
7730 }
7731 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
7732 }
7733}
7734impl serde::Serialize for ResumeMutation {
7735 #[allow(deprecated)]
7736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7737 where
7738 S: serde::Serializer,
7739 {
7740 use serde::ser::SerializeStruct;
7741 let len = 0;
7742 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
7743 struct_ser.end()
7744 }
7745}
7746impl<'de> serde::Deserialize<'de> for ResumeMutation {
7747 #[allow(deprecated)]
7748 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7749 where
7750 D: serde::Deserializer<'de>,
7751 {
7752 const FIELDS: &[&str] = &[
7753 ];
7754
7755 #[allow(clippy::enum_variant_names)]
7756 enum GeneratedField {
7757 }
7758 impl<'de> serde::Deserialize<'de> for GeneratedField {
7759 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7760 where
7761 D: serde::Deserializer<'de>,
7762 {
7763 struct GeneratedVisitor;
7764
7765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7766 type Value = GeneratedField;
7767
7768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7769 write!(formatter, "expected one of: {:?}", &FIELDS)
7770 }
7771
7772 #[allow(unused_variables)]
7773 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7774 where
7775 E: serde::de::Error,
7776 {
7777 Err(serde::de::Error::unknown_field(value, FIELDS))
7778 }
7779 }
7780 deserializer.deserialize_identifier(GeneratedVisitor)
7781 }
7782 }
7783 struct GeneratedVisitor;
7784 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7785 type Value = ResumeMutation;
7786
7787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7788 formatter.write_str("struct stream_plan.ResumeMutation")
7789 }
7790
7791 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
7792 where
7793 V: serde::de::MapAccess<'de>,
7794 {
7795 while map_.next_key::<GeneratedField>()?.is_some() {
7796 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7797 }
7798 Ok(ResumeMutation {
7799 })
7800 }
7801 }
7802 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
7803 }
7804}
7805impl serde::Serialize for RowIdGenNode {
7806 #[allow(deprecated)]
7807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7808 where
7809 S: serde::Serializer,
7810 {
7811 use serde::ser::SerializeStruct;
7812 let mut len = 0;
7813 if self.row_id_index != 0 {
7814 len += 1;
7815 }
7816 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
7817 if self.row_id_index != 0 {
7818 #[allow(clippy::needless_borrow)]
7819 #[allow(clippy::needless_borrows_for_generic_args)]
7820 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
7821 }
7822 struct_ser.end()
7823 }
7824}
7825impl<'de> serde::Deserialize<'de> for RowIdGenNode {
7826 #[allow(deprecated)]
7827 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7828 where
7829 D: serde::Deserializer<'de>,
7830 {
7831 const FIELDS: &[&str] = &[
7832 "row_id_index",
7833 "rowIdIndex",
7834 ];
7835
7836 #[allow(clippy::enum_variant_names)]
7837 enum GeneratedField {
7838 RowIdIndex,
7839 }
7840 impl<'de> serde::Deserialize<'de> for GeneratedField {
7841 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7842 where
7843 D: serde::Deserializer<'de>,
7844 {
7845 struct GeneratedVisitor;
7846
7847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7848 type Value = GeneratedField;
7849
7850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7851 write!(formatter, "expected one of: {:?}", &FIELDS)
7852 }
7853
7854 #[allow(unused_variables)]
7855 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7856 where
7857 E: serde::de::Error,
7858 {
7859 match value {
7860 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
7861 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7862 }
7863 }
7864 }
7865 deserializer.deserialize_identifier(GeneratedVisitor)
7866 }
7867 }
7868 struct GeneratedVisitor;
7869 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7870 type Value = RowIdGenNode;
7871
7872 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7873 formatter.write_str("struct stream_plan.RowIdGenNode")
7874 }
7875
7876 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
7877 where
7878 V: serde::de::MapAccess<'de>,
7879 {
7880 let mut row_id_index__ = None;
7881 while let Some(k) = map_.next_key()? {
7882 match k {
7883 GeneratedField::RowIdIndex => {
7884 if row_id_index__.is_some() {
7885 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
7886 }
7887 row_id_index__ =
7888 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7889 ;
7890 }
7891 }
7892 }
7893 Ok(RowIdGenNode {
7894 row_id_index: row_id_index__.unwrap_or_default(),
7895 })
7896 }
7897 }
7898 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
7899 }
7900}
7901impl serde::Serialize for RowMergeNode {
7902 #[allow(deprecated)]
7903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7904 where
7905 S: serde::Serializer,
7906 {
7907 use serde::ser::SerializeStruct;
7908 let mut len = 0;
7909 if self.lhs_mapping.is_some() {
7910 len += 1;
7911 }
7912 if self.rhs_mapping.is_some() {
7913 len += 1;
7914 }
7915 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
7916 if let Some(v) = self.lhs_mapping.as_ref() {
7917 struct_ser.serialize_field("lhsMapping", v)?;
7918 }
7919 if let Some(v) = self.rhs_mapping.as_ref() {
7920 struct_ser.serialize_field("rhsMapping", v)?;
7921 }
7922 struct_ser.end()
7923 }
7924}
7925impl<'de> serde::Deserialize<'de> for RowMergeNode {
7926 #[allow(deprecated)]
7927 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7928 where
7929 D: serde::Deserializer<'de>,
7930 {
7931 const FIELDS: &[&str] = &[
7932 "lhs_mapping",
7933 "lhsMapping",
7934 "rhs_mapping",
7935 "rhsMapping",
7936 ];
7937
7938 #[allow(clippy::enum_variant_names)]
7939 enum GeneratedField {
7940 LhsMapping,
7941 RhsMapping,
7942 }
7943 impl<'de> serde::Deserialize<'de> for GeneratedField {
7944 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7945 where
7946 D: serde::Deserializer<'de>,
7947 {
7948 struct GeneratedVisitor;
7949
7950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7951 type Value = GeneratedField;
7952
7953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7954 write!(formatter, "expected one of: {:?}", &FIELDS)
7955 }
7956
7957 #[allow(unused_variables)]
7958 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7959 where
7960 E: serde::de::Error,
7961 {
7962 match value {
7963 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
7964 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
7965 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7966 }
7967 }
7968 }
7969 deserializer.deserialize_identifier(GeneratedVisitor)
7970 }
7971 }
7972 struct GeneratedVisitor;
7973 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7974 type Value = RowMergeNode;
7975
7976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7977 formatter.write_str("struct stream_plan.RowMergeNode")
7978 }
7979
7980 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
7981 where
7982 V: serde::de::MapAccess<'de>,
7983 {
7984 let mut lhs_mapping__ = None;
7985 let mut rhs_mapping__ = None;
7986 while let Some(k) = map_.next_key()? {
7987 match k {
7988 GeneratedField::LhsMapping => {
7989 if lhs_mapping__.is_some() {
7990 return Err(serde::de::Error::duplicate_field("lhsMapping"));
7991 }
7992 lhs_mapping__ = map_.next_value()?;
7993 }
7994 GeneratedField::RhsMapping => {
7995 if rhs_mapping__.is_some() {
7996 return Err(serde::de::Error::duplicate_field("rhsMapping"));
7997 }
7998 rhs_mapping__ = map_.next_value()?;
7999 }
8000 }
8001 }
8002 Ok(RowMergeNode {
8003 lhs_mapping: lhs_mapping__,
8004 rhs_mapping: rhs_mapping__,
8005 })
8006 }
8007 }
8008 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8009 }
8010}
8011impl serde::Serialize for SimpleAggNode {
8012 #[allow(deprecated)]
8013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8014 where
8015 S: serde::Serializer,
8016 {
8017 use serde::ser::SerializeStruct;
8018 let mut len = 0;
8019 if !self.agg_calls.is_empty() {
8020 len += 1;
8021 }
8022 if !self.distribution_key.is_empty() {
8023 len += 1;
8024 }
8025 if !self.agg_call_states.is_empty() {
8026 len += 1;
8027 }
8028 if self.intermediate_state_table.is_some() {
8029 len += 1;
8030 }
8031 if self.is_append_only {
8032 len += 1;
8033 }
8034 if !self.distinct_dedup_tables.is_empty() {
8035 len += 1;
8036 }
8037 if self.row_count_index != 0 {
8038 len += 1;
8039 }
8040 if self.version != 0 {
8041 len += 1;
8042 }
8043 if self.must_output_per_barrier {
8044 len += 1;
8045 }
8046 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8047 if !self.agg_calls.is_empty() {
8048 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8049 }
8050 if !self.distribution_key.is_empty() {
8051 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8052 }
8053 if !self.agg_call_states.is_empty() {
8054 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8055 }
8056 if let Some(v) = self.intermediate_state_table.as_ref() {
8057 struct_ser.serialize_field("intermediateStateTable", v)?;
8058 }
8059 if self.is_append_only {
8060 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8061 }
8062 if !self.distinct_dedup_tables.is_empty() {
8063 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8064 }
8065 if self.row_count_index != 0 {
8066 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8067 }
8068 if self.version != 0 {
8069 let v = AggNodeVersion::try_from(self.version)
8070 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8071 struct_ser.serialize_field("version", &v)?;
8072 }
8073 if self.must_output_per_barrier {
8074 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8075 }
8076 struct_ser.end()
8077 }
8078}
8079impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8080 #[allow(deprecated)]
8081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8082 where
8083 D: serde::Deserializer<'de>,
8084 {
8085 const FIELDS: &[&str] = &[
8086 "agg_calls",
8087 "aggCalls",
8088 "distribution_key",
8089 "distributionKey",
8090 "agg_call_states",
8091 "aggCallStates",
8092 "intermediate_state_table",
8093 "intermediateStateTable",
8094 "is_append_only",
8095 "isAppendOnly",
8096 "distinct_dedup_tables",
8097 "distinctDedupTables",
8098 "row_count_index",
8099 "rowCountIndex",
8100 "version",
8101 "must_output_per_barrier",
8102 "mustOutputPerBarrier",
8103 ];
8104
8105 #[allow(clippy::enum_variant_names)]
8106 enum GeneratedField {
8107 AggCalls,
8108 DistributionKey,
8109 AggCallStates,
8110 IntermediateStateTable,
8111 IsAppendOnly,
8112 DistinctDedupTables,
8113 RowCountIndex,
8114 Version,
8115 MustOutputPerBarrier,
8116 }
8117 impl<'de> serde::Deserialize<'de> for GeneratedField {
8118 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8119 where
8120 D: serde::Deserializer<'de>,
8121 {
8122 struct GeneratedVisitor;
8123
8124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8125 type Value = GeneratedField;
8126
8127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8128 write!(formatter, "expected one of: {:?}", &FIELDS)
8129 }
8130
8131 #[allow(unused_variables)]
8132 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8133 where
8134 E: serde::de::Error,
8135 {
8136 match value {
8137 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8138 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8139 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8140 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8141 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8142 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8143 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8144 "version" => Ok(GeneratedField::Version),
8145 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8146 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8147 }
8148 }
8149 }
8150 deserializer.deserialize_identifier(GeneratedVisitor)
8151 }
8152 }
8153 struct GeneratedVisitor;
8154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8155 type Value = SimpleAggNode;
8156
8157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8158 formatter.write_str("struct stream_plan.SimpleAggNode")
8159 }
8160
8161 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8162 where
8163 V: serde::de::MapAccess<'de>,
8164 {
8165 let mut agg_calls__ = None;
8166 let mut distribution_key__ = None;
8167 let mut agg_call_states__ = None;
8168 let mut intermediate_state_table__ = None;
8169 let mut is_append_only__ = None;
8170 let mut distinct_dedup_tables__ = None;
8171 let mut row_count_index__ = None;
8172 let mut version__ = None;
8173 let mut must_output_per_barrier__ = None;
8174 while let Some(k) = map_.next_key()? {
8175 match k {
8176 GeneratedField::AggCalls => {
8177 if agg_calls__.is_some() {
8178 return Err(serde::de::Error::duplicate_field("aggCalls"));
8179 }
8180 agg_calls__ = Some(map_.next_value()?);
8181 }
8182 GeneratedField::DistributionKey => {
8183 if distribution_key__.is_some() {
8184 return Err(serde::de::Error::duplicate_field("distributionKey"));
8185 }
8186 distribution_key__ =
8187 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8188 .into_iter().map(|x| x.0).collect())
8189 ;
8190 }
8191 GeneratedField::AggCallStates => {
8192 if agg_call_states__.is_some() {
8193 return Err(serde::de::Error::duplicate_field("aggCallStates"));
8194 }
8195 agg_call_states__ = Some(map_.next_value()?);
8196 }
8197 GeneratedField::IntermediateStateTable => {
8198 if intermediate_state_table__.is_some() {
8199 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8200 }
8201 intermediate_state_table__ = map_.next_value()?;
8202 }
8203 GeneratedField::IsAppendOnly => {
8204 if is_append_only__.is_some() {
8205 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8206 }
8207 is_append_only__ = Some(map_.next_value()?);
8208 }
8209 GeneratedField::DistinctDedupTables => {
8210 if distinct_dedup_tables__.is_some() {
8211 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8212 }
8213 distinct_dedup_tables__ = Some(
8214 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8215 .into_iter().map(|(k,v)| (k.0, v)).collect()
8216 );
8217 }
8218 GeneratedField::RowCountIndex => {
8219 if row_count_index__.is_some() {
8220 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8221 }
8222 row_count_index__ =
8223 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8224 ;
8225 }
8226 GeneratedField::Version => {
8227 if version__.is_some() {
8228 return Err(serde::de::Error::duplicate_field("version"));
8229 }
8230 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8231 }
8232 GeneratedField::MustOutputPerBarrier => {
8233 if must_output_per_barrier__.is_some() {
8234 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8235 }
8236 must_output_per_barrier__ = Some(map_.next_value()?);
8237 }
8238 }
8239 }
8240 Ok(SimpleAggNode {
8241 agg_calls: agg_calls__.unwrap_or_default(),
8242 distribution_key: distribution_key__.unwrap_or_default(),
8243 agg_call_states: agg_call_states__.unwrap_or_default(),
8244 intermediate_state_table: intermediate_state_table__,
8245 is_append_only: is_append_only__.unwrap_or_default(),
8246 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8247 row_count_index: row_count_index__.unwrap_or_default(),
8248 version: version__.unwrap_or_default(),
8249 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8250 })
8251 }
8252 }
8253 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8254 }
8255}
8256impl serde::Serialize for SinkDesc {
8257 #[allow(deprecated)]
8258 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8259 where
8260 S: serde::Serializer,
8261 {
8262 use serde::ser::SerializeStruct;
8263 let mut len = 0;
8264 if self.id != 0 {
8265 len += 1;
8266 }
8267 if !self.name.is_empty() {
8268 len += 1;
8269 }
8270 if !self.definition.is_empty() {
8271 len += 1;
8272 }
8273 if !self.plan_pk.is_empty() {
8274 len += 1;
8275 }
8276 if !self.downstream_pk.is_empty() {
8277 len += 1;
8278 }
8279 if !self.distribution_key.is_empty() {
8280 len += 1;
8281 }
8282 if !self.properties.is_empty() {
8283 len += 1;
8284 }
8285 if self.sink_type != 0 {
8286 len += 1;
8287 }
8288 if !self.column_catalogs.is_empty() {
8289 len += 1;
8290 }
8291 if !self.db_name.is_empty() {
8292 len += 1;
8293 }
8294 if !self.sink_from_name.is_empty() {
8295 len += 1;
8296 }
8297 if self.format_desc.is_some() {
8298 len += 1;
8299 }
8300 if self.target_table.is_some() {
8301 len += 1;
8302 }
8303 if self.extra_partition_col_idx.is_some() {
8304 len += 1;
8305 }
8306 if !self.secret_refs.is_empty() {
8307 len += 1;
8308 }
8309 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8310 if self.id != 0 {
8311 struct_ser.serialize_field("id", &self.id)?;
8312 }
8313 if !self.name.is_empty() {
8314 struct_ser.serialize_field("name", &self.name)?;
8315 }
8316 if !self.definition.is_empty() {
8317 struct_ser.serialize_field("definition", &self.definition)?;
8318 }
8319 if !self.plan_pk.is_empty() {
8320 struct_ser.serialize_field("planPk", &self.plan_pk)?;
8321 }
8322 if !self.downstream_pk.is_empty() {
8323 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8324 }
8325 if !self.distribution_key.is_empty() {
8326 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8327 }
8328 if !self.properties.is_empty() {
8329 struct_ser.serialize_field("properties", &self.properties)?;
8330 }
8331 if self.sink_type != 0 {
8332 let v = super::catalog::SinkType::try_from(self.sink_type)
8333 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8334 struct_ser.serialize_field("sinkType", &v)?;
8335 }
8336 if !self.column_catalogs.is_empty() {
8337 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8338 }
8339 if !self.db_name.is_empty() {
8340 struct_ser.serialize_field("dbName", &self.db_name)?;
8341 }
8342 if !self.sink_from_name.is_empty() {
8343 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8344 }
8345 if let Some(v) = self.format_desc.as_ref() {
8346 struct_ser.serialize_field("formatDesc", v)?;
8347 }
8348 if let Some(v) = self.target_table.as_ref() {
8349 struct_ser.serialize_field("targetTable", v)?;
8350 }
8351 if let Some(v) = self.extra_partition_col_idx.as_ref() {
8352 #[allow(clippy::needless_borrow)]
8353 #[allow(clippy::needless_borrows_for_generic_args)]
8354 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8355 }
8356 if !self.secret_refs.is_empty() {
8357 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8358 }
8359 struct_ser.end()
8360 }
8361}
8362impl<'de> serde::Deserialize<'de> for SinkDesc {
8363 #[allow(deprecated)]
8364 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8365 where
8366 D: serde::Deserializer<'de>,
8367 {
8368 const FIELDS: &[&str] = &[
8369 "id",
8370 "name",
8371 "definition",
8372 "plan_pk",
8373 "planPk",
8374 "downstream_pk",
8375 "downstreamPk",
8376 "distribution_key",
8377 "distributionKey",
8378 "properties",
8379 "sink_type",
8380 "sinkType",
8381 "column_catalogs",
8382 "columnCatalogs",
8383 "db_name",
8384 "dbName",
8385 "sink_from_name",
8386 "sinkFromName",
8387 "format_desc",
8388 "formatDesc",
8389 "target_table",
8390 "targetTable",
8391 "extra_partition_col_idx",
8392 "extraPartitionColIdx",
8393 "secret_refs",
8394 "secretRefs",
8395 ];
8396
8397 #[allow(clippy::enum_variant_names)]
8398 enum GeneratedField {
8399 Id,
8400 Name,
8401 Definition,
8402 PlanPk,
8403 DownstreamPk,
8404 DistributionKey,
8405 Properties,
8406 SinkType,
8407 ColumnCatalogs,
8408 DbName,
8409 SinkFromName,
8410 FormatDesc,
8411 TargetTable,
8412 ExtraPartitionColIdx,
8413 SecretRefs,
8414 }
8415 impl<'de> serde::Deserialize<'de> for GeneratedField {
8416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8417 where
8418 D: serde::Deserializer<'de>,
8419 {
8420 struct GeneratedVisitor;
8421
8422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8423 type Value = GeneratedField;
8424
8425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8426 write!(formatter, "expected one of: {:?}", &FIELDS)
8427 }
8428
8429 #[allow(unused_variables)]
8430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8431 where
8432 E: serde::de::Error,
8433 {
8434 match value {
8435 "id" => Ok(GeneratedField::Id),
8436 "name" => Ok(GeneratedField::Name),
8437 "definition" => Ok(GeneratedField::Definition),
8438 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
8439 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
8440 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8441 "properties" => Ok(GeneratedField::Properties),
8442 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
8443 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
8444 "dbName" | "db_name" => Ok(GeneratedField::DbName),
8445 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
8446 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
8447 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
8448 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
8449 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
8450 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8451 }
8452 }
8453 }
8454 deserializer.deserialize_identifier(GeneratedVisitor)
8455 }
8456 }
8457 struct GeneratedVisitor;
8458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8459 type Value = SinkDesc;
8460
8461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8462 formatter.write_str("struct stream_plan.SinkDesc")
8463 }
8464
8465 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
8466 where
8467 V: serde::de::MapAccess<'de>,
8468 {
8469 let mut id__ = None;
8470 let mut name__ = None;
8471 let mut definition__ = None;
8472 let mut plan_pk__ = None;
8473 let mut downstream_pk__ = None;
8474 let mut distribution_key__ = None;
8475 let mut properties__ = None;
8476 let mut sink_type__ = None;
8477 let mut column_catalogs__ = None;
8478 let mut db_name__ = None;
8479 let mut sink_from_name__ = None;
8480 let mut format_desc__ = None;
8481 let mut target_table__ = None;
8482 let mut extra_partition_col_idx__ = None;
8483 let mut secret_refs__ = None;
8484 while let Some(k) = map_.next_key()? {
8485 match k {
8486 GeneratedField::Id => {
8487 if id__.is_some() {
8488 return Err(serde::de::Error::duplicate_field("id"));
8489 }
8490 id__ =
8491 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8492 ;
8493 }
8494 GeneratedField::Name => {
8495 if name__.is_some() {
8496 return Err(serde::de::Error::duplicate_field("name"));
8497 }
8498 name__ = Some(map_.next_value()?);
8499 }
8500 GeneratedField::Definition => {
8501 if definition__.is_some() {
8502 return Err(serde::de::Error::duplicate_field("definition"));
8503 }
8504 definition__ = Some(map_.next_value()?);
8505 }
8506 GeneratedField::PlanPk => {
8507 if plan_pk__.is_some() {
8508 return Err(serde::de::Error::duplicate_field("planPk"));
8509 }
8510 plan_pk__ = Some(map_.next_value()?);
8511 }
8512 GeneratedField::DownstreamPk => {
8513 if downstream_pk__.is_some() {
8514 return Err(serde::de::Error::duplicate_field("downstreamPk"));
8515 }
8516 downstream_pk__ =
8517 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8518 .into_iter().map(|x| x.0).collect())
8519 ;
8520 }
8521 GeneratedField::DistributionKey => {
8522 if distribution_key__.is_some() {
8523 return Err(serde::de::Error::duplicate_field("distributionKey"));
8524 }
8525 distribution_key__ =
8526 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8527 .into_iter().map(|x| x.0).collect())
8528 ;
8529 }
8530 GeneratedField::Properties => {
8531 if properties__.is_some() {
8532 return Err(serde::de::Error::duplicate_field("properties"));
8533 }
8534 properties__ = Some(
8535 map_.next_value::<std::collections::BTreeMap<_, _>>()?
8536 );
8537 }
8538 GeneratedField::SinkType => {
8539 if sink_type__.is_some() {
8540 return Err(serde::de::Error::duplicate_field("sinkType"));
8541 }
8542 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
8543 }
8544 GeneratedField::ColumnCatalogs => {
8545 if column_catalogs__.is_some() {
8546 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
8547 }
8548 column_catalogs__ = Some(map_.next_value()?);
8549 }
8550 GeneratedField::DbName => {
8551 if db_name__.is_some() {
8552 return Err(serde::de::Error::duplicate_field("dbName"));
8553 }
8554 db_name__ = Some(map_.next_value()?);
8555 }
8556 GeneratedField::SinkFromName => {
8557 if sink_from_name__.is_some() {
8558 return Err(serde::de::Error::duplicate_field("sinkFromName"));
8559 }
8560 sink_from_name__ = Some(map_.next_value()?);
8561 }
8562 GeneratedField::FormatDesc => {
8563 if format_desc__.is_some() {
8564 return Err(serde::de::Error::duplicate_field("formatDesc"));
8565 }
8566 format_desc__ = map_.next_value()?;
8567 }
8568 GeneratedField::TargetTable => {
8569 if target_table__.is_some() {
8570 return Err(serde::de::Error::duplicate_field("targetTable"));
8571 }
8572 target_table__ =
8573 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8574 ;
8575 }
8576 GeneratedField::ExtraPartitionColIdx => {
8577 if extra_partition_col_idx__.is_some() {
8578 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
8579 }
8580 extra_partition_col_idx__ =
8581 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8582 ;
8583 }
8584 GeneratedField::SecretRefs => {
8585 if secret_refs__.is_some() {
8586 return Err(serde::de::Error::duplicate_field("secretRefs"));
8587 }
8588 secret_refs__ = Some(
8589 map_.next_value::<std::collections::BTreeMap<_, _>>()?
8590 );
8591 }
8592 }
8593 }
8594 Ok(SinkDesc {
8595 id: id__.unwrap_or_default(),
8596 name: name__.unwrap_or_default(),
8597 definition: definition__.unwrap_or_default(),
8598 plan_pk: plan_pk__.unwrap_or_default(),
8599 downstream_pk: downstream_pk__.unwrap_or_default(),
8600 distribution_key: distribution_key__.unwrap_or_default(),
8601 properties: properties__.unwrap_or_default(),
8602 sink_type: sink_type__.unwrap_or_default(),
8603 column_catalogs: column_catalogs__.unwrap_or_default(),
8604 db_name: db_name__.unwrap_or_default(),
8605 sink_from_name: sink_from_name__.unwrap_or_default(),
8606 format_desc: format_desc__,
8607 target_table: target_table__,
8608 extra_partition_col_idx: extra_partition_col_idx__,
8609 secret_refs: secret_refs__.unwrap_or_default(),
8610 })
8611 }
8612 }
8613 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
8614 }
8615}
8616impl serde::Serialize for SinkLogStoreType {
8617 #[allow(deprecated)]
8618 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8619 where
8620 S: serde::Serializer,
8621 {
8622 let variant = match self {
8623 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8624 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8625 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8626 };
8627 serializer.serialize_str(variant)
8628 }
8629}
8630impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
8631 #[allow(deprecated)]
8632 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8633 where
8634 D: serde::Deserializer<'de>,
8635 {
8636 const FIELDS: &[&str] = &[
8637 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8638 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8639 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8640 ];
8641
8642 struct GeneratedVisitor;
8643
8644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8645 type Value = SinkLogStoreType;
8646
8647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8648 write!(formatter, "expected one of: {:?}", &FIELDS)
8649 }
8650
8651 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8652 where
8653 E: serde::de::Error,
8654 {
8655 i32::try_from(v)
8656 .ok()
8657 .and_then(|x| x.try_into().ok())
8658 .ok_or_else(|| {
8659 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8660 })
8661 }
8662
8663 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8664 where
8665 E: serde::de::Error,
8666 {
8667 i32::try_from(v)
8668 .ok()
8669 .and_then(|x| x.try_into().ok())
8670 .ok_or_else(|| {
8671 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8672 })
8673 }
8674
8675 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8676 where
8677 E: serde::de::Error,
8678 {
8679 match value {
8680 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
8681 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
8682 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
8683 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8684 }
8685 }
8686 }
8687 deserializer.deserialize_any(GeneratedVisitor)
8688 }
8689}
8690impl serde::Serialize for SinkNode {
8691 #[allow(deprecated)]
8692 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8693 where
8694 S: serde::Serializer,
8695 {
8696 use serde::ser::SerializeStruct;
8697 let mut len = 0;
8698 if self.sink_desc.is_some() {
8699 len += 1;
8700 }
8701 if self.table.is_some() {
8702 len += 1;
8703 }
8704 if self.log_store_type != 0 {
8705 len += 1;
8706 }
8707 if self.rate_limit.is_some() {
8708 len += 1;
8709 }
8710 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
8711 if let Some(v) = self.sink_desc.as_ref() {
8712 struct_ser.serialize_field("sinkDesc", v)?;
8713 }
8714 if let Some(v) = self.table.as_ref() {
8715 struct_ser.serialize_field("table", v)?;
8716 }
8717 if self.log_store_type != 0 {
8718 let v = SinkLogStoreType::try_from(self.log_store_type)
8719 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
8720 struct_ser.serialize_field("logStoreType", &v)?;
8721 }
8722 if let Some(v) = self.rate_limit.as_ref() {
8723 struct_ser.serialize_field("rateLimit", v)?;
8724 }
8725 struct_ser.end()
8726 }
8727}
8728impl<'de> serde::Deserialize<'de> for SinkNode {
8729 #[allow(deprecated)]
8730 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8731 where
8732 D: serde::Deserializer<'de>,
8733 {
8734 const FIELDS: &[&str] = &[
8735 "sink_desc",
8736 "sinkDesc",
8737 "table",
8738 "log_store_type",
8739 "logStoreType",
8740 "rate_limit",
8741 "rateLimit",
8742 ];
8743
8744 #[allow(clippy::enum_variant_names)]
8745 enum GeneratedField {
8746 SinkDesc,
8747 Table,
8748 LogStoreType,
8749 RateLimit,
8750 }
8751 impl<'de> serde::Deserialize<'de> for GeneratedField {
8752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8753 where
8754 D: serde::Deserializer<'de>,
8755 {
8756 struct GeneratedVisitor;
8757
8758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8759 type Value = GeneratedField;
8760
8761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8762 write!(formatter, "expected one of: {:?}", &FIELDS)
8763 }
8764
8765 #[allow(unused_variables)]
8766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8767 where
8768 E: serde::de::Error,
8769 {
8770 match value {
8771 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
8772 "table" => Ok(GeneratedField::Table),
8773 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
8774 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8775 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8776 }
8777 }
8778 }
8779 deserializer.deserialize_identifier(GeneratedVisitor)
8780 }
8781 }
8782 struct GeneratedVisitor;
8783 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8784 type Value = SinkNode;
8785
8786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8787 formatter.write_str("struct stream_plan.SinkNode")
8788 }
8789
8790 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
8791 where
8792 V: serde::de::MapAccess<'de>,
8793 {
8794 let mut sink_desc__ = None;
8795 let mut table__ = None;
8796 let mut log_store_type__ = None;
8797 let mut rate_limit__ = None;
8798 while let Some(k) = map_.next_key()? {
8799 match k {
8800 GeneratedField::SinkDesc => {
8801 if sink_desc__.is_some() {
8802 return Err(serde::de::Error::duplicate_field("sinkDesc"));
8803 }
8804 sink_desc__ = map_.next_value()?;
8805 }
8806 GeneratedField::Table => {
8807 if table__.is_some() {
8808 return Err(serde::de::Error::duplicate_field("table"));
8809 }
8810 table__ = map_.next_value()?;
8811 }
8812 GeneratedField::LogStoreType => {
8813 if log_store_type__.is_some() {
8814 return Err(serde::de::Error::duplicate_field("logStoreType"));
8815 }
8816 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
8817 }
8818 GeneratedField::RateLimit => {
8819 if rate_limit__.is_some() {
8820 return Err(serde::de::Error::duplicate_field("rateLimit"));
8821 }
8822 rate_limit__ =
8823 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8824 ;
8825 }
8826 }
8827 }
8828 Ok(SinkNode {
8829 sink_desc: sink_desc__,
8830 table: table__,
8831 log_store_type: log_store_type__.unwrap_or_default(),
8832 rate_limit: rate_limit__,
8833 })
8834 }
8835 }
8836 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
8837 }
8838}
8839impl serde::Serialize for SortNode {
8840 #[allow(deprecated)]
8841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8842 where
8843 S: serde::Serializer,
8844 {
8845 use serde::ser::SerializeStruct;
8846 let mut len = 0;
8847 if self.state_table.is_some() {
8848 len += 1;
8849 }
8850 if self.sort_column_index != 0 {
8851 len += 1;
8852 }
8853 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
8854 if let Some(v) = self.state_table.as_ref() {
8855 struct_ser.serialize_field("stateTable", v)?;
8856 }
8857 if self.sort_column_index != 0 {
8858 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
8859 }
8860 struct_ser.end()
8861 }
8862}
8863impl<'de> serde::Deserialize<'de> for SortNode {
8864 #[allow(deprecated)]
8865 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8866 where
8867 D: serde::Deserializer<'de>,
8868 {
8869 const FIELDS: &[&str] = &[
8870 "state_table",
8871 "stateTable",
8872 "sort_column_index",
8873 "sortColumnIndex",
8874 ];
8875
8876 #[allow(clippy::enum_variant_names)]
8877 enum GeneratedField {
8878 StateTable,
8879 SortColumnIndex,
8880 }
8881 impl<'de> serde::Deserialize<'de> for GeneratedField {
8882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8883 where
8884 D: serde::Deserializer<'de>,
8885 {
8886 struct GeneratedVisitor;
8887
8888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8889 type Value = GeneratedField;
8890
8891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8892 write!(formatter, "expected one of: {:?}", &FIELDS)
8893 }
8894
8895 #[allow(unused_variables)]
8896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8897 where
8898 E: serde::de::Error,
8899 {
8900 match value {
8901 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8902 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
8903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8904 }
8905 }
8906 }
8907 deserializer.deserialize_identifier(GeneratedVisitor)
8908 }
8909 }
8910 struct GeneratedVisitor;
8911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8912 type Value = SortNode;
8913
8914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8915 formatter.write_str("struct stream_plan.SortNode")
8916 }
8917
8918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
8919 where
8920 V: serde::de::MapAccess<'de>,
8921 {
8922 let mut state_table__ = None;
8923 let mut sort_column_index__ = None;
8924 while let Some(k) = map_.next_key()? {
8925 match k {
8926 GeneratedField::StateTable => {
8927 if state_table__.is_some() {
8928 return Err(serde::de::Error::duplicate_field("stateTable"));
8929 }
8930 state_table__ = map_.next_value()?;
8931 }
8932 GeneratedField::SortColumnIndex => {
8933 if sort_column_index__.is_some() {
8934 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
8935 }
8936 sort_column_index__ =
8937 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8938 ;
8939 }
8940 }
8941 }
8942 Ok(SortNode {
8943 state_table: state_table__,
8944 sort_column_index: sort_column_index__.unwrap_or_default(),
8945 })
8946 }
8947 }
8948 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
8949 }
8950}
8951impl serde::Serialize for SourceBackfillNode {
8952 #[allow(deprecated)]
8953 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8954 where
8955 S: serde::Serializer,
8956 {
8957 use serde::ser::SerializeStruct;
8958 let mut len = 0;
8959 if self.upstream_source_id != 0 {
8960 len += 1;
8961 }
8962 if self.row_id_index.is_some() {
8963 len += 1;
8964 }
8965 if !self.columns.is_empty() {
8966 len += 1;
8967 }
8968 if self.info.is_some() {
8969 len += 1;
8970 }
8971 if !self.source_name.is_empty() {
8972 len += 1;
8973 }
8974 if !self.with_properties.is_empty() {
8975 len += 1;
8976 }
8977 if self.rate_limit.is_some() {
8978 len += 1;
8979 }
8980 if self.state_table.is_some() {
8981 len += 1;
8982 }
8983 if !self.secret_refs.is_empty() {
8984 len += 1;
8985 }
8986 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
8987 if self.upstream_source_id != 0 {
8988 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
8989 }
8990 if let Some(v) = self.row_id_index.as_ref() {
8991 struct_ser.serialize_field("rowIdIndex", v)?;
8992 }
8993 if !self.columns.is_empty() {
8994 struct_ser.serialize_field("columns", &self.columns)?;
8995 }
8996 if let Some(v) = self.info.as_ref() {
8997 struct_ser.serialize_field("info", v)?;
8998 }
8999 if !self.source_name.is_empty() {
9000 struct_ser.serialize_field("sourceName", &self.source_name)?;
9001 }
9002 if !self.with_properties.is_empty() {
9003 struct_ser.serialize_field("withProperties", &self.with_properties)?;
9004 }
9005 if let Some(v) = self.rate_limit.as_ref() {
9006 struct_ser.serialize_field("rateLimit", v)?;
9007 }
9008 if let Some(v) = self.state_table.as_ref() {
9009 struct_ser.serialize_field("stateTable", v)?;
9010 }
9011 if !self.secret_refs.is_empty() {
9012 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9013 }
9014 struct_ser.end()
9015 }
9016}
9017impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9018 #[allow(deprecated)]
9019 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9020 where
9021 D: serde::Deserializer<'de>,
9022 {
9023 const FIELDS: &[&str] = &[
9024 "upstream_source_id",
9025 "upstreamSourceId",
9026 "row_id_index",
9027 "rowIdIndex",
9028 "columns",
9029 "info",
9030 "source_name",
9031 "sourceName",
9032 "with_properties",
9033 "withProperties",
9034 "rate_limit",
9035 "rateLimit",
9036 "state_table",
9037 "stateTable",
9038 "secret_refs",
9039 "secretRefs",
9040 ];
9041
9042 #[allow(clippy::enum_variant_names)]
9043 enum GeneratedField {
9044 UpstreamSourceId,
9045 RowIdIndex,
9046 Columns,
9047 Info,
9048 SourceName,
9049 WithProperties,
9050 RateLimit,
9051 StateTable,
9052 SecretRefs,
9053 }
9054 impl<'de> serde::Deserialize<'de> for GeneratedField {
9055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9056 where
9057 D: serde::Deserializer<'de>,
9058 {
9059 struct GeneratedVisitor;
9060
9061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9062 type Value = GeneratedField;
9063
9064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9065 write!(formatter, "expected one of: {:?}", &FIELDS)
9066 }
9067
9068 #[allow(unused_variables)]
9069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9070 where
9071 E: serde::de::Error,
9072 {
9073 match value {
9074 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9075 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9076 "columns" => Ok(GeneratedField::Columns),
9077 "info" => Ok(GeneratedField::Info),
9078 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9079 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9080 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9081 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9082 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9083 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9084 }
9085 }
9086 }
9087 deserializer.deserialize_identifier(GeneratedVisitor)
9088 }
9089 }
9090 struct GeneratedVisitor;
9091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9092 type Value = SourceBackfillNode;
9093
9094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9095 formatter.write_str("struct stream_plan.SourceBackfillNode")
9096 }
9097
9098 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9099 where
9100 V: serde::de::MapAccess<'de>,
9101 {
9102 let mut upstream_source_id__ = None;
9103 let mut row_id_index__ = None;
9104 let mut columns__ = None;
9105 let mut info__ = None;
9106 let mut source_name__ = None;
9107 let mut with_properties__ = None;
9108 let mut rate_limit__ = None;
9109 let mut state_table__ = None;
9110 let mut secret_refs__ = None;
9111 while let Some(k) = map_.next_key()? {
9112 match k {
9113 GeneratedField::UpstreamSourceId => {
9114 if upstream_source_id__.is_some() {
9115 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9116 }
9117 upstream_source_id__ =
9118 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9119 ;
9120 }
9121 GeneratedField::RowIdIndex => {
9122 if row_id_index__.is_some() {
9123 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9124 }
9125 row_id_index__ =
9126 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9127 ;
9128 }
9129 GeneratedField::Columns => {
9130 if columns__.is_some() {
9131 return Err(serde::de::Error::duplicate_field("columns"));
9132 }
9133 columns__ = Some(map_.next_value()?);
9134 }
9135 GeneratedField::Info => {
9136 if info__.is_some() {
9137 return Err(serde::de::Error::duplicate_field("info"));
9138 }
9139 info__ = map_.next_value()?;
9140 }
9141 GeneratedField::SourceName => {
9142 if source_name__.is_some() {
9143 return Err(serde::de::Error::duplicate_field("sourceName"));
9144 }
9145 source_name__ = Some(map_.next_value()?);
9146 }
9147 GeneratedField::WithProperties => {
9148 if with_properties__.is_some() {
9149 return Err(serde::de::Error::duplicate_field("withProperties"));
9150 }
9151 with_properties__ = Some(
9152 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9153 );
9154 }
9155 GeneratedField::RateLimit => {
9156 if rate_limit__.is_some() {
9157 return Err(serde::de::Error::duplicate_field("rateLimit"));
9158 }
9159 rate_limit__ =
9160 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9161 ;
9162 }
9163 GeneratedField::StateTable => {
9164 if state_table__.is_some() {
9165 return Err(serde::de::Error::duplicate_field("stateTable"));
9166 }
9167 state_table__ = map_.next_value()?;
9168 }
9169 GeneratedField::SecretRefs => {
9170 if secret_refs__.is_some() {
9171 return Err(serde::de::Error::duplicate_field("secretRefs"));
9172 }
9173 secret_refs__ = Some(
9174 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9175 );
9176 }
9177 }
9178 }
9179 Ok(SourceBackfillNode {
9180 upstream_source_id: upstream_source_id__.unwrap_or_default(),
9181 row_id_index: row_id_index__,
9182 columns: columns__.unwrap_or_default(),
9183 info: info__,
9184 source_name: source_name__.unwrap_or_default(),
9185 with_properties: with_properties__.unwrap_or_default(),
9186 rate_limit: rate_limit__,
9187 state_table: state_table__,
9188 secret_refs: secret_refs__.unwrap_or_default(),
9189 })
9190 }
9191 }
9192 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9193 }
9194}
9195impl serde::Serialize for SourceChangeSplitMutation {
9196 #[allow(deprecated)]
9197 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9198 where
9199 S: serde::Serializer,
9200 {
9201 use serde::ser::SerializeStruct;
9202 let mut len = 0;
9203 if !self.actor_splits.is_empty() {
9204 len += 1;
9205 }
9206 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9207 if !self.actor_splits.is_empty() {
9208 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9209 }
9210 struct_ser.end()
9211 }
9212}
9213impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9214 #[allow(deprecated)]
9215 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9216 where
9217 D: serde::Deserializer<'de>,
9218 {
9219 const FIELDS: &[&str] = &[
9220 "actor_splits",
9221 "actorSplits",
9222 ];
9223
9224 #[allow(clippy::enum_variant_names)]
9225 enum GeneratedField {
9226 ActorSplits,
9227 }
9228 impl<'de> serde::Deserialize<'de> for GeneratedField {
9229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9230 where
9231 D: serde::Deserializer<'de>,
9232 {
9233 struct GeneratedVisitor;
9234
9235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9236 type Value = GeneratedField;
9237
9238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9239 write!(formatter, "expected one of: {:?}", &FIELDS)
9240 }
9241
9242 #[allow(unused_variables)]
9243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9244 where
9245 E: serde::de::Error,
9246 {
9247 match value {
9248 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9249 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9250 }
9251 }
9252 }
9253 deserializer.deserialize_identifier(GeneratedVisitor)
9254 }
9255 }
9256 struct GeneratedVisitor;
9257 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9258 type Value = SourceChangeSplitMutation;
9259
9260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9261 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9262 }
9263
9264 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9265 where
9266 V: serde::de::MapAccess<'de>,
9267 {
9268 let mut actor_splits__ = None;
9269 while let Some(k) = map_.next_key()? {
9270 match k {
9271 GeneratedField::ActorSplits => {
9272 if actor_splits__.is_some() {
9273 return Err(serde::de::Error::duplicate_field("actorSplits"));
9274 }
9275 actor_splits__ = Some(
9276 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9277 .into_iter().map(|(k,v)| (k.0, v)).collect()
9278 );
9279 }
9280 }
9281 }
9282 Ok(SourceChangeSplitMutation {
9283 actor_splits: actor_splits__.unwrap_or_default(),
9284 })
9285 }
9286 }
9287 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9288 }
9289}
9290impl serde::Serialize for SourceNode {
9291 #[allow(deprecated)]
9292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9293 where
9294 S: serde::Serializer,
9295 {
9296 use serde::ser::SerializeStruct;
9297 let mut len = 0;
9298 if self.source_inner.is_some() {
9299 len += 1;
9300 }
9301 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9302 if let Some(v) = self.source_inner.as_ref() {
9303 struct_ser.serialize_field("sourceInner", v)?;
9304 }
9305 struct_ser.end()
9306 }
9307}
9308impl<'de> serde::Deserialize<'de> for SourceNode {
9309 #[allow(deprecated)]
9310 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9311 where
9312 D: serde::Deserializer<'de>,
9313 {
9314 const FIELDS: &[&str] = &[
9315 "source_inner",
9316 "sourceInner",
9317 ];
9318
9319 #[allow(clippy::enum_variant_names)]
9320 enum GeneratedField {
9321 SourceInner,
9322 }
9323 impl<'de> serde::Deserialize<'de> for GeneratedField {
9324 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9325 where
9326 D: serde::Deserializer<'de>,
9327 {
9328 struct GeneratedVisitor;
9329
9330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9331 type Value = GeneratedField;
9332
9333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9334 write!(formatter, "expected one of: {:?}", &FIELDS)
9335 }
9336
9337 #[allow(unused_variables)]
9338 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9339 where
9340 E: serde::de::Error,
9341 {
9342 match value {
9343 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9344 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9345 }
9346 }
9347 }
9348 deserializer.deserialize_identifier(GeneratedVisitor)
9349 }
9350 }
9351 struct GeneratedVisitor;
9352 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9353 type Value = SourceNode;
9354
9355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9356 formatter.write_str("struct stream_plan.SourceNode")
9357 }
9358
9359 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9360 where
9361 V: serde::de::MapAccess<'de>,
9362 {
9363 let mut source_inner__ = None;
9364 while let Some(k) = map_.next_key()? {
9365 match k {
9366 GeneratedField::SourceInner => {
9367 if source_inner__.is_some() {
9368 return Err(serde::de::Error::duplicate_field("sourceInner"));
9369 }
9370 source_inner__ = map_.next_value()?;
9371 }
9372 }
9373 }
9374 Ok(SourceNode {
9375 source_inner: source_inner__,
9376 })
9377 }
9378 }
9379 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
9380 }
9381}
9382impl serde::Serialize for StartFragmentBackfillMutation {
9383 #[allow(deprecated)]
9384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9385 where
9386 S: serde::Serializer,
9387 {
9388 use serde::ser::SerializeStruct;
9389 let mut len = 0;
9390 if !self.fragment_ids.is_empty() {
9391 len += 1;
9392 }
9393 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
9394 if !self.fragment_ids.is_empty() {
9395 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
9396 }
9397 struct_ser.end()
9398 }
9399}
9400impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
9401 #[allow(deprecated)]
9402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9403 where
9404 D: serde::Deserializer<'de>,
9405 {
9406 const FIELDS: &[&str] = &[
9407 "fragment_ids",
9408 "fragmentIds",
9409 ];
9410
9411 #[allow(clippy::enum_variant_names)]
9412 enum GeneratedField {
9413 FragmentIds,
9414 }
9415 impl<'de> serde::Deserialize<'de> for GeneratedField {
9416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9417 where
9418 D: serde::Deserializer<'de>,
9419 {
9420 struct GeneratedVisitor;
9421
9422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9423 type Value = GeneratedField;
9424
9425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9426 write!(formatter, "expected one of: {:?}", &FIELDS)
9427 }
9428
9429 #[allow(unused_variables)]
9430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9431 where
9432 E: serde::de::Error,
9433 {
9434 match value {
9435 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
9436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9437 }
9438 }
9439 }
9440 deserializer.deserialize_identifier(GeneratedVisitor)
9441 }
9442 }
9443 struct GeneratedVisitor;
9444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9445 type Value = StartFragmentBackfillMutation;
9446
9447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9448 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
9449 }
9450
9451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
9452 where
9453 V: serde::de::MapAccess<'de>,
9454 {
9455 let mut fragment_ids__ = None;
9456 while let Some(k) = map_.next_key()? {
9457 match k {
9458 GeneratedField::FragmentIds => {
9459 if fragment_ids__.is_some() {
9460 return Err(serde::de::Error::duplicate_field("fragmentIds"));
9461 }
9462 fragment_ids__ =
9463 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9464 .into_iter().map(|x| x.0).collect())
9465 ;
9466 }
9467 }
9468 }
9469 Ok(StartFragmentBackfillMutation {
9470 fragment_ids: fragment_ids__.unwrap_or_default(),
9471 })
9472 }
9473 }
9474 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
9475 }
9476}
9477impl serde::Serialize for StopMutation {
9478 #[allow(deprecated)]
9479 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9480 where
9481 S: serde::Serializer,
9482 {
9483 use serde::ser::SerializeStruct;
9484 let mut len = 0;
9485 if !self.actors.is_empty() {
9486 len += 1;
9487 }
9488 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
9489 if !self.actors.is_empty() {
9490 struct_ser.serialize_field("actors", &self.actors)?;
9491 }
9492 struct_ser.end()
9493 }
9494}
9495impl<'de> serde::Deserialize<'de> for StopMutation {
9496 #[allow(deprecated)]
9497 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9498 where
9499 D: serde::Deserializer<'de>,
9500 {
9501 const FIELDS: &[&str] = &[
9502 "actors",
9503 ];
9504
9505 #[allow(clippy::enum_variant_names)]
9506 enum GeneratedField {
9507 Actors,
9508 }
9509 impl<'de> serde::Deserialize<'de> for GeneratedField {
9510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9511 where
9512 D: serde::Deserializer<'de>,
9513 {
9514 struct GeneratedVisitor;
9515
9516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9517 type Value = GeneratedField;
9518
9519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9520 write!(formatter, "expected one of: {:?}", &FIELDS)
9521 }
9522
9523 #[allow(unused_variables)]
9524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9525 where
9526 E: serde::de::Error,
9527 {
9528 match value {
9529 "actors" => Ok(GeneratedField::Actors),
9530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9531 }
9532 }
9533 }
9534 deserializer.deserialize_identifier(GeneratedVisitor)
9535 }
9536 }
9537 struct GeneratedVisitor;
9538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9539 type Value = StopMutation;
9540
9541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9542 formatter.write_str("struct stream_plan.StopMutation")
9543 }
9544
9545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
9546 where
9547 V: serde::de::MapAccess<'de>,
9548 {
9549 let mut actors__ = None;
9550 while let Some(k) = map_.next_key()? {
9551 match k {
9552 GeneratedField::Actors => {
9553 if actors__.is_some() {
9554 return Err(serde::de::Error::duplicate_field("actors"));
9555 }
9556 actors__ =
9557 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9558 .into_iter().map(|x| x.0).collect())
9559 ;
9560 }
9561 }
9562 }
9563 Ok(StopMutation {
9564 actors: actors__.unwrap_or_default(),
9565 })
9566 }
9567 }
9568 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
9569 }
9570}
9571impl serde::Serialize for StreamActor {
9572 #[allow(deprecated)]
9573 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9574 where
9575 S: serde::Serializer,
9576 {
9577 use serde::ser::SerializeStruct;
9578 let mut len = 0;
9579 if self.actor_id != 0 {
9580 len += 1;
9581 }
9582 if self.fragment_id != 0 {
9583 len += 1;
9584 }
9585 if !self.dispatcher.is_empty() {
9586 len += 1;
9587 }
9588 if self.vnode_bitmap.is_some() {
9589 len += 1;
9590 }
9591 if !self.mview_definition.is_empty() {
9592 len += 1;
9593 }
9594 if self.expr_context.is_some() {
9595 len += 1;
9596 }
9597 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
9598 if self.actor_id != 0 {
9599 struct_ser.serialize_field("actorId", &self.actor_id)?;
9600 }
9601 if self.fragment_id != 0 {
9602 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9603 }
9604 if !self.dispatcher.is_empty() {
9605 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
9606 }
9607 if let Some(v) = self.vnode_bitmap.as_ref() {
9608 struct_ser.serialize_field("vnodeBitmap", v)?;
9609 }
9610 if !self.mview_definition.is_empty() {
9611 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
9612 }
9613 if let Some(v) = self.expr_context.as_ref() {
9614 struct_ser.serialize_field("exprContext", v)?;
9615 }
9616 struct_ser.end()
9617 }
9618}
9619impl<'de> serde::Deserialize<'de> for StreamActor {
9620 #[allow(deprecated)]
9621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9622 where
9623 D: serde::Deserializer<'de>,
9624 {
9625 const FIELDS: &[&str] = &[
9626 "actor_id",
9627 "actorId",
9628 "fragment_id",
9629 "fragmentId",
9630 "dispatcher",
9631 "vnode_bitmap",
9632 "vnodeBitmap",
9633 "mview_definition",
9634 "mviewDefinition",
9635 "expr_context",
9636 "exprContext",
9637 ];
9638
9639 #[allow(clippy::enum_variant_names)]
9640 enum GeneratedField {
9641 ActorId,
9642 FragmentId,
9643 Dispatcher,
9644 VnodeBitmap,
9645 MviewDefinition,
9646 ExprContext,
9647 }
9648 impl<'de> serde::Deserialize<'de> for GeneratedField {
9649 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9650 where
9651 D: serde::Deserializer<'de>,
9652 {
9653 struct GeneratedVisitor;
9654
9655 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9656 type Value = GeneratedField;
9657
9658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9659 write!(formatter, "expected one of: {:?}", &FIELDS)
9660 }
9661
9662 #[allow(unused_variables)]
9663 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9664 where
9665 E: serde::de::Error,
9666 {
9667 match value {
9668 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9669 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9670 "dispatcher" => Ok(GeneratedField::Dispatcher),
9671 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
9672 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
9673 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
9674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9675 }
9676 }
9677 }
9678 deserializer.deserialize_identifier(GeneratedVisitor)
9679 }
9680 }
9681 struct GeneratedVisitor;
9682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9683 type Value = StreamActor;
9684
9685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9686 formatter.write_str("struct stream_plan.StreamActor")
9687 }
9688
9689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
9690 where
9691 V: serde::de::MapAccess<'de>,
9692 {
9693 let mut actor_id__ = None;
9694 let mut fragment_id__ = None;
9695 let mut dispatcher__ = None;
9696 let mut vnode_bitmap__ = None;
9697 let mut mview_definition__ = None;
9698 let mut expr_context__ = None;
9699 while let Some(k) = map_.next_key()? {
9700 match k {
9701 GeneratedField::ActorId => {
9702 if actor_id__.is_some() {
9703 return Err(serde::de::Error::duplicate_field("actorId"));
9704 }
9705 actor_id__ =
9706 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9707 ;
9708 }
9709 GeneratedField::FragmentId => {
9710 if fragment_id__.is_some() {
9711 return Err(serde::de::Error::duplicate_field("fragmentId"));
9712 }
9713 fragment_id__ =
9714 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9715 ;
9716 }
9717 GeneratedField::Dispatcher => {
9718 if dispatcher__.is_some() {
9719 return Err(serde::de::Error::duplicate_field("dispatcher"));
9720 }
9721 dispatcher__ = Some(map_.next_value()?);
9722 }
9723 GeneratedField::VnodeBitmap => {
9724 if vnode_bitmap__.is_some() {
9725 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
9726 }
9727 vnode_bitmap__ = map_.next_value()?;
9728 }
9729 GeneratedField::MviewDefinition => {
9730 if mview_definition__.is_some() {
9731 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
9732 }
9733 mview_definition__ = Some(map_.next_value()?);
9734 }
9735 GeneratedField::ExprContext => {
9736 if expr_context__.is_some() {
9737 return Err(serde::de::Error::duplicate_field("exprContext"));
9738 }
9739 expr_context__ = map_.next_value()?;
9740 }
9741 }
9742 }
9743 Ok(StreamActor {
9744 actor_id: actor_id__.unwrap_or_default(),
9745 fragment_id: fragment_id__.unwrap_or_default(),
9746 dispatcher: dispatcher__.unwrap_or_default(),
9747 vnode_bitmap: vnode_bitmap__,
9748 mview_definition: mview_definition__.unwrap_or_default(),
9749 expr_context: expr_context__,
9750 })
9751 }
9752 }
9753 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
9754 }
9755}
9756impl serde::Serialize for StreamCdcScanNode {
9757 #[allow(deprecated)]
9758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9759 where
9760 S: serde::Serializer,
9761 {
9762 use serde::ser::SerializeStruct;
9763 let mut len = 0;
9764 if self.table_id != 0 {
9765 len += 1;
9766 }
9767 if !self.upstream_column_ids.is_empty() {
9768 len += 1;
9769 }
9770 if !self.output_indices.is_empty() {
9771 len += 1;
9772 }
9773 if self.state_table.is_some() {
9774 len += 1;
9775 }
9776 if self.cdc_table_desc.is_some() {
9777 len += 1;
9778 }
9779 if self.rate_limit.is_some() {
9780 len += 1;
9781 }
9782 if self.disable_backfill {
9783 len += 1;
9784 }
9785 if self.options.is_some() {
9786 len += 1;
9787 }
9788 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
9789 if self.table_id != 0 {
9790 struct_ser.serialize_field("tableId", &self.table_id)?;
9791 }
9792 if !self.upstream_column_ids.is_empty() {
9793 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
9794 }
9795 if !self.output_indices.is_empty() {
9796 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
9797 }
9798 if let Some(v) = self.state_table.as_ref() {
9799 struct_ser.serialize_field("stateTable", v)?;
9800 }
9801 if let Some(v) = self.cdc_table_desc.as_ref() {
9802 struct_ser.serialize_field("cdcTableDesc", v)?;
9803 }
9804 if let Some(v) = self.rate_limit.as_ref() {
9805 struct_ser.serialize_field("rateLimit", v)?;
9806 }
9807 if self.disable_backfill {
9808 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
9809 }
9810 if let Some(v) = self.options.as_ref() {
9811 struct_ser.serialize_field("options", v)?;
9812 }
9813 struct_ser.end()
9814 }
9815}
9816impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
9817 #[allow(deprecated)]
9818 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9819 where
9820 D: serde::Deserializer<'de>,
9821 {
9822 const FIELDS: &[&str] = &[
9823 "table_id",
9824 "tableId",
9825 "upstream_column_ids",
9826 "upstreamColumnIds",
9827 "output_indices",
9828 "outputIndices",
9829 "state_table",
9830 "stateTable",
9831 "cdc_table_desc",
9832 "cdcTableDesc",
9833 "rate_limit",
9834 "rateLimit",
9835 "disable_backfill",
9836 "disableBackfill",
9837 "options",
9838 ];
9839
9840 #[allow(clippy::enum_variant_names)]
9841 enum GeneratedField {
9842 TableId,
9843 UpstreamColumnIds,
9844 OutputIndices,
9845 StateTable,
9846 CdcTableDesc,
9847 RateLimit,
9848 DisableBackfill,
9849 Options,
9850 }
9851 impl<'de> serde::Deserialize<'de> for GeneratedField {
9852 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9853 where
9854 D: serde::Deserializer<'de>,
9855 {
9856 struct GeneratedVisitor;
9857
9858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9859 type Value = GeneratedField;
9860
9861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9862 write!(formatter, "expected one of: {:?}", &FIELDS)
9863 }
9864
9865 #[allow(unused_variables)]
9866 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9867 where
9868 E: serde::de::Error,
9869 {
9870 match value {
9871 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9872 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
9873 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
9874 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9875 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
9876 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9877 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
9878 "options" => Ok(GeneratedField::Options),
9879 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9880 }
9881 }
9882 }
9883 deserializer.deserialize_identifier(GeneratedVisitor)
9884 }
9885 }
9886 struct GeneratedVisitor;
9887 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9888 type Value = StreamCdcScanNode;
9889
9890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9891 formatter.write_str("struct stream_plan.StreamCdcScanNode")
9892 }
9893
9894 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
9895 where
9896 V: serde::de::MapAccess<'de>,
9897 {
9898 let mut table_id__ = None;
9899 let mut upstream_column_ids__ = None;
9900 let mut output_indices__ = None;
9901 let mut state_table__ = None;
9902 let mut cdc_table_desc__ = None;
9903 let mut rate_limit__ = None;
9904 let mut disable_backfill__ = None;
9905 let mut options__ = None;
9906 while let Some(k) = map_.next_key()? {
9907 match k {
9908 GeneratedField::TableId => {
9909 if table_id__.is_some() {
9910 return Err(serde::de::Error::duplicate_field("tableId"));
9911 }
9912 table_id__ =
9913 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9914 ;
9915 }
9916 GeneratedField::UpstreamColumnIds => {
9917 if upstream_column_ids__.is_some() {
9918 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
9919 }
9920 upstream_column_ids__ =
9921 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9922 .into_iter().map(|x| x.0).collect())
9923 ;
9924 }
9925 GeneratedField::OutputIndices => {
9926 if output_indices__.is_some() {
9927 return Err(serde::de::Error::duplicate_field("outputIndices"));
9928 }
9929 output_indices__ =
9930 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9931 .into_iter().map(|x| x.0).collect())
9932 ;
9933 }
9934 GeneratedField::StateTable => {
9935 if state_table__.is_some() {
9936 return Err(serde::de::Error::duplicate_field("stateTable"));
9937 }
9938 state_table__ = map_.next_value()?;
9939 }
9940 GeneratedField::CdcTableDesc => {
9941 if cdc_table_desc__.is_some() {
9942 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
9943 }
9944 cdc_table_desc__ = map_.next_value()?;
9945 }
9946 GeneratedField::RateLimit => {
9947 if rate_limit__.is_some() {
9948 return Err(serde::de::Error::duplicate_field("rateLimit"));
9949 }
9950 rate_limit__ =
9951 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9952 ;
9953 }
9954 GeneratedField::DisableBackfill => {
9955 if disable_backfill__.is_some() {
9956 return Err(serde::de::Error::duplicate_field("disableBackfill"));
9957 }
9958 disable_backfill__ = Some(map_.next_value()?);
9959 }
9960 GeneratedField::Options => {
9961 if options__.is_some() {
9962 return Err(serde::de::Error::duplicate_field("options"));
9963 }
9964 options__ = map_.next_value()?;
9965 }
9966 }
9967 }
9968 Ok(StreamCdcScanNode {
9969 table_id: table_id__.unwrap_or_default(),
9970 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
9971 output_indices: output_indices__.unwrap_or_default(),
9972 state_table: state_table__,
9973 cdc_table_desc: cdc_table_desc__,
9974 rate_limit: rate_limit__,
9975 disable_backfill: disable_backfill__.unwrap_or_default(),
9976 options: options__,
9977 })
9978 }
9979 }
9980 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
9981 }
9982}
9983impl serde::Serialize for StreamCdcScanOptions {
9984 #[allow(deprecated)]
9985 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9986 where
9987 S: serde::Serializer,
9988 {
9989 use serde::ser::SerializeStruct;
9990 let mut len = 0;
9991 if self.disable_backfill {
9992 len += 1;
9993 }
9994 if self.snapshot_barrier_interval != 0 {
9995 len += 1;
9996 }
9997 if self.snapshot_batch_size != 0 {
9998 len += 1;
9999 }
10000 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10001 if self.disable_backfill {
10002 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10003 }
10004 if self.snapshot_barrier_interval != 0 {
10005 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10006 }
10007 if self.snapshot_batch_size != 0 {
10008 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10009 }
10010 struct_ser.end()
10011 }
10012}
10013impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10014 #[allow(deprecated)]
10015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10016 where
10017 D: serde::Deserializer<'de>,
10018 {
10019 const FIELDS: &[&str] = &[
10020 "disable_backfill",
10021 "disableBackfill",
10022 "snapshot_barrier_interval",
10023 "snapshotBarrierInterval",
10024 "snapshot_batch_size",
10025 "snapshotBatchSize",
10026 ];
10027
10028 #[allow(clippy::enum_variant_names)]
10029 enum GeneratedField {
10030 DisableBackfill,
10031 SnapshotBarrierInterval,
10032 SnapshotBatchSize,
10033 }
10034 impl<'de> serde::Deserialize<'de> for GeneratedField {
10035 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10036 where
10037 D: serde::Deserializer<'de>,
10038 {
10039 struct GeneratedVisitor;
10040
10041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10042 type Value = GeneratedField;
10043
10044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10045 write!(formatter, "expected one of: {:?}", &FIELDS)
10046 }
10047
10048 #[allow(unused_variables)]
10049 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10050 where
10051 E: serde::de::Error,
10052 {
10053 match value {
10054 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10055 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10056 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10057 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10058 }
10059 }
10060 }
10061 deserializer.deserialize_identifier(GeneratedVisitor)
10062 }
10063 }
10064 struct GeneratedVisitor;
10065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10066 type Value = StreamCdcScanOptions;
10067
10068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10069 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10070 }
10071
10072 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10073 where
10074 V: serde::de::MapAccess<'de>,
10075 {
10076 let mut disable_backfill__ = None;
10077 let mut snapshot_barrier_interval__ = None;
10078 let mut snapshot_batch_size__ = None;
10079 while let Some(k) = map_.next_key()? {
10080 match k {
10081 GeneratedField::DisableBackfill => {
10082 if disable_backfill__.is_some() {
10083 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10084 }
10085 disable_backfill__ = Some(map_.next_value()?);
10086 }
10087 GeneratedField::SnapshotBarrierInterval => {
10088 if snapshot_barrier_interval__.is_some() {
10089 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10090 }
10091 snapshot_barrier_interval__ =
10092 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10093 ;
10094 }
10095 GeneratedField::SnapshotBatchSize => {
10096 if snapshot_batch_size__.is_some() {
10097 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10098 }
10099 snapshot_batch_size__ =
10100 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10101 ;
10102 }
10103 }
10104 }
10105 Ok(StreamCdcScanOptions {
10106 disable_backfill: disable_backfill__.unwrap_or_default(),
10107 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10108 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10109 })
10110 }
10111 }
10112 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10113 }
10114}
10115impl serde::Serialize for StreamContext {
10116 #[allow(deprecated)]
10117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10118 where
10119 S: serde::Serializer,
10120 {
10121 use serde::ser::SerializeStruct;
10122 let mut len = 0;
10123 if !self.timezone.is_empty() {
10124 len += 1;
10125 }
10126 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10127 if !self.timezone.is_empty() {
10128 struct_ser.serialize_field("timezone", &self.timezone)?;
10129 }
10130 struct_ser.end()
10131 }
10132}
10133impl<'de> serde::Deserialize<'de> for StreamContext {
10134 #[allow(deprecated)]
10135 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10136 where
10137 D: serde::Deserializer<'de>,
10138 {
10139 const FIELDS: &[&str] = &[
10140 "timezone",
10141 ];
10142
10143 #[allow(clippy::enum_variant_names)]
10144 enum GeneratedField {
10145 Timezone,
10146 }
10147 impl<'de> serde::Deserialize<'de> for GeneratedField {
10148 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10149 where
10150 D: serde::Deserializer<'de>,
10151 {
10152 struct GeneratedVisitor;
10153
10154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10155 type Value = GeneratedField;
10156
10157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10158 write!(formatter, "expected one of: {:?}", &FIELDS)
10159 }
10160
10161 #[allow(unused_variables)]
10162 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10163 where
10164 E: serde::de::Error,
10165 {
10166 match value {
10167 "timezone" => Ok(GeneratedField::Timezone),
10168 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10169 }
10170 }
10171 }
10172 deserializer.deserialize_identifier(GeneratedVisitor)
10173 }
10174 }
10175 struct GeneratedVisitor;
10176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10177 type Value = StreamContext;
10178
10179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10180 formatter.write_str("struct stream_plan.StreamContext")
10181 }
10182
10183 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10184 where
10185 V: serde::de::MapAccess<'de>,
10186 {
10187 let mut timezone__ = None;
10188 while let Some(k) = map_.next_key()? {
10189 match k {
10190 GeneratedField::Timezone => {
10191 if timezone__.is_some() {
10192 return Err(serde::de::Error::duplicate_field("timezone"));
10193 }
10194 timezone__ = Some(map_.next_value()?);
10195 }
10196 }
10197 }
10198 Ok(StreamContext {
10199 timezone: timezone__.unwrap_or_default(),
10200 })
10201 }
10202 }
10203 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10204 }
10205}
10206impl serde::Serialize for StreamFragmentGraph {
10207 #[allow(deprecated)]
10208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10209 where
10210 S: serde::Serializer,
10211 {
10212 use serde::ser::SerializeStruct;
10213 let mut len = 0;
10214 if !self.fragments.is_empty() {
10215 len += 1;
10216 }
10217 if !self.edges.is_empty() {
10218 len += 1;
10219 }
10220 if !self.dependent_table_ids.is_empty() {
10221 len += 1;
10222 }
10223 if self.table_ids_cnt != 0 {
10224 len += 1;
10225 }
10226 if self.ctx.is_some() {
10227 len += 1;
10228 }
10229 if self.parallelism.is_some() {
10230 len += 1;
10231 }
10232 if self.max_parallelism != 0 {
10233 len += 1;
10234 }
10235 if self.backfill_order.is_some() {
10236 len += 1;
10237 }
10238 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10239 if !self.fragments.is_empty() {
10240 struct_ser.serialize_field("fragments", &self.fragments)?;
10241 }
10242 if !self.edges.is_empty() {
10243 struct_ser.serialize_field("edges", &self.edges)?;
10244 }
10245 if !self.dependent_table_ids.is_empty() {
10246 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10247 }
10248 if self.table_ids_cnt != 0 {
10249 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10250 }
10251 if let Some(v) = self.ctx.as_ref() {
10252 struct_ser.serialize_field("ctx", v)?;
10253 }
10254 if let Some(v) = self.parallelism.as_ref() {
10255 struct_ser.serialize_field("parallelism", v)?;
10256 }
10257 if self.max_parallelism != 0 {
10258 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10259 }
10260 if let Some(v) = self.backfill_order.as_ref() {
10261 struct_ser.serialize_field("backfillOrder", v)?;
10262 }
10263 struct_ser.end()
10264 }
10265}
10266impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
10267 #[allow(deprecated)]
10268 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10269 where
10270 D: serde::Deserializer<'de>,
10271 {
10272 const FIELDS: &[&str] = &[
10273 "fragments",
10274 "edges",
10275 "dependent_table_ids",
10276 "dependentTableIds",
10277 "table_ids_cnt",
10278 "tableIdsCnt",
10279 "ctx",
10280 "parallelism",
10281 "max_parallelism",
10282 "maxParallelism",
10283 "backfill_order",
10284 "backfillOrder",
10285 ];
10286
10287 #[allow(clippy::enum_variant_names)]
10288 enum GeneratedField {
10289 Fragments,
10290 Edges,
10291 DependentTableIds,
10292 TableIdsCnt,
10293 Ctx,
10294 Parallelism,
10295 MaxParallelism,
10296 BackfillOrder,
10297 }
10298 impl<'de> serde::Deserialize<'de> for GeneratedField {
10299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10300 where
10301 D: serde::Deserializer<'de>,
10302 {
10303 struct GeneratedVisitor;
10304
10305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10306 type Value = GeneratedField;
10307
10308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10309 write!(formatter, "expected one of: {:?}", &FIELDS)
10310 }
10311
10312 #[allow(unused_variables)]
10313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10314 where
10315 E: serde::de::Error,
10316 {
10317 match value {
10318 "fragments" => Ok(GeneratedField::Fragments),
10319 "edges" => Ok(GeneratedField::Edges),
10320 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
10321 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10322 "ctx" => Ok(GeneratedField::Ctx),
10323 "parallelism" => Ok(GeneratedField::Parallelism),
10324 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10325 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
10326 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10327 }
10328 }
10329 }
10330 deserializer.deserialize_identifier(GeneratedVisitor)
10331 }
10332 }
10333 struct GeneratedVisitor;
10334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10335 type Value = StreamFragmentGraph;
10336
10337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10338 formatter.write_str("struct stream_plan.StreamFragmentGraph")
10339 }
10340
10341 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
10342 where
10343 V: serde::de::MapAccess<'de>,
10344 {
10345 let mut fragments__ = None;
10346 let mut edges__ = None;
10347 let mut dependent_table_ids__ = None;
10348 let mut table_ids_cnt__ = None;
10349 let mut ctx__ = None;
10350 let mut parallelism__ = None;
10351 let mut max_parallelism__ = None;
10352 let mut backfill_order__ = None;
10353 while let Some(k) = map_.next_key()? {
10354 match k {
10355 GeneratedField::Fragments => {
10356 if fragments__.is_some() {
10357 return Err(serde::de::Error::duplicate_field("fragments"));
10358 }
10359 fragments__ = Some(
10360 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10361 .into_iter().map(|(k,v)| (k.0, v)).collect()
10362 );
10363 }
10364 GeneratedField::Edges => {
10365 if edges__.is_some() {
10366 return Err(serde::de::Error::duplicate_field("edges"));
10367 }
10368 edges__ = Some(map_.next_value()?);
10369 }
10370 GeneratedField::DependentTableIds => {
10371 if dependent_table_ids__.is_some() {
10372 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
10373 }
10374 dependent_table_ids__ =
10375 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10376 .into_iter().map(|x| x.0).collect())
10377 ;
10378 }
10379 GeneratedField::TableIdsCnt => {
10380 if table_ids_cnt__.is_some() {
10381 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10382 }
10383 table_ids_cnt__ =
10384 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10385 ;
10386 }
10387 GeneratedField::Ctx => {
10388 if ctx__.is_some() {
10389 return Err(serde::de::Error::duplicate_field("ctx"));
10390 }
10391 ctx__ = map_.next_value()?;
10392 }
10393 GeneratedField::Parallelism => {
10394 if parallelism__.is_some() {
10395 return Err(serde::de::Error::duplicate_field("parallelism"));
10396 }
10397 parallelism__ = map_.next_value()?;
10398 }
10399 GeneratedField::MaxParallelism => {
10400 if max_parallelism__.is_some() {
10401 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10402 }
10403 max_parallelism__ =
10404 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10405 ;
10406 }
10407 GeneratedField::BackfillOrder => {
10408 if backfill_order__.is_some() {
10409 return Err(serde::de::Error::duplicate_field("backfillOrder"));
10410 }
10411 backfill_order__ = map_.next_value()?;
10412 }
10413 }
10414 }
10415 Ok(StreamFragmentGraph {
10416 fragments: fragments__.unwrap_or_default(),
10417 edges: edges__.unwrap_or_default(),
10418 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
10419 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10420 ctx: ctx__,
10421 parallelism: parallelism__,
10422 max_parallelism: max_parallelism__.unwrap_or_default(),
10423 backfill_order: backfill_order__,
10424 })
10425 }
10426 }
10427 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
10428 }
10429}
10430impl serde::Serialize for stream_fragment_graph::Parallelism {
10431 #[allow(deprecated)]
10432 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10433 where
10434 S: serde::Serializer,
10435 {
10436 use serde::ser::SerializeStruct;
10437 let mut len = 0;
10438 if self.parallelism != 0 {
10439 len += 1;
10440 }
10441 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
10442 if self.parallelism != 0 {
10443 #[allow(clippy::needless_borrow)]
10444 #[allow(clippy::needless_borrows_for_generic_args)]
10445 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
10446 }
10447 struct_ser.end()
10448 }
10449}
10450impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
10451 #[allow(deprecated)]
10452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10453 where
10454 D: serde::Deserializer<'de>,
10455 {
10456 const FIELDS: &[&str] = &[
10457 "parallelism",
10458 ];
10459
10460 #[allow(clippy::enum_variant_names)]
10461 enum GeneratedField {
10462 Parallelism,
10463 }
10464 impl<'de> serde::Deserialize<'de> for GeneratedField {
10465 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10466 where
10467 D: serde::Deserializer<'de>,
10468 {
10469 struct GeneratedVisitor;
10470
10471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10472 type Value = GeneratedField;
10473
10474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10475 write!(formatter, "expected one of: {:?}", &FIELDS)
10476 }
10477
10478 #[allow(unused_variables)]
10479 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10480 where
10481 E: serde::de::Error,
10482 {
10483 match value {
10484 "parallelism" => Ok(GeneratedField::Parallelism),
10485 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10486 }
10487 }
10488 }
10489 deserializer.deserialize_identifier(GeneratedVisitor)
10490 }
10491 }
10492 struct GeneratedVisitor;
10493 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10494 type Value = stream_fragment_graph::Parallelism;
10495
10496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10497 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
10498 }
10499
10500 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
10501 where
10502 V: serde::de::MapAccess<'de>,
10503 {
10504 let mut parallelism__ = None;
10505 while let Some(k) = map_.next_key()? {
10506 match k {
10507 GeneratedField::Parallelism => {
10508 if parallelism__.is_some() {
10509 return Err(serde::de::Error::duplicate_field("parallelism"));
10510 }
10511 parallelism__ =
10512 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10513 ;
10514 }
10515 }
10516 }
10517 Ok(stream_fragment_graph::Parallelism {
10518 parallelism: parallelism__.unwrap_or_default(),
10519 })
10520 }
10521 }
10522 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
10523 }
10524}
10525impl serde::Serialize for stream_fragment_graph::StreamFragment {
10526 #[allow(deprecated)]
10527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10528 where
10529 S: serde::Serializer,
10530 {
10531 use serde::ser::SerializeStruct;
10532 let mut len = 0;
10533 if self.fragment_id != 0 {
10534 len += 1;
10535 }
10536 if self.node.is_some() {
10537 len += 1;
10538 }
10539 if self.fragment_type_mask != 0 {
10540 len += 1;
10541 }
10542 if self.requires_singleton {
10543 len += 1;
10544 }
10545 if self.table_ids_cnt != 0 {
10546 len += 1;
10547 }
10548 if !self.upstream_table_ids.is_empty() {
10549 len += 1;
10550 }
10551 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
10552 if self.fragment_id != 0 {
10553 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10554 }
10555 if let Some(v) = self.node.as_ref() {
10556 struct_ser.serialize_field("node", v)?;
10557 }
10558 if self.fragment_type_mask != 0 {
10559 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10560 }
10561 if self.requires_singleton {
10562 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
10563 }
10564 if self.table_ids_cnt != 0 {
10565 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10566 }
10567 if !self.upstream_table_ids.is_empty() {
10568 struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
10569 }
10570 struct_ser.end()
10571 }
10572}
10573impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
10574 #[allow(deprecated)]
10575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10576 where
10577 D: serde::Deserializer<'de>,
10578 {
10579 const FIELDS: &[&str] = &[
10580 "fragment_id",
10581 "fragmentId",
10582 "node",
10583 "fragment_type_mask",
10584 "fragmentTypeMask",
10585 "requires_singleton",
10586 "requiresSingleton",
10587 "table_ids_cnt",
10588 "tableIdsCnt",
10589 "upstream_table_ids",
10590 "upstreamTableIds",
10591 ];
10592
10593 #[allow(clippy::enum_variant_names)]
10594 enum GeneratedField {
10595 FragmentId,
10596 Node,
10597 FragmentTypeMask,
10598 RequiresSingleton,
10599 TableIdsCnt,
10600 UpstreamTableIds,
10601 }
10602 impl<'de> serde::Deserialize<'de> for GeneratedField {
10603 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10604 where
10605 D: serde::Deserializer<'de>,
10606 {
10607 struct GeneratedVisitor;
10608
10609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10610 type Value = GeneratedField;
10611
10612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10613 write!(formatter, "expected one of: {:?}", &FIELDS)
10614 }
10615
10616 #[allow(unused_variables)]
10617 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10618 where
10619 E: serde::de::Error,
10620 {
10621 match value {
10622 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10623 "node" => Ok(GeneratedField::Node),
10624 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10625 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
10626 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10627 "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
10628 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10629 }
10630 }
10631 }
10632 deserializer.deserialize_identifier(GeneratedVisitor)
10633 }
10634 }
10635 struct GeneratedVisitor;
10636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10637 type Value = stream_fragment_graph::StreamFragment;
10638
10639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10640 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
10641 }
10642
10643 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
10644 where
10645 V: serde::de::MapAccess<'de>,
10646 {
10647 let mut fragment_id__ = None;
10648 let mut node__ = None;
10649 let mut fragment_type_mask__ = None;
10650 let mut requires_singleton__ = None;
10651 let mut table_ids_cnt__ = None;
10652 let mut upstream_table_ids__ = None;
10653 while let Some(k) = map_.next_key()? {
10654 match k {
10655 GeneratedField::FragmentId => {
10656 if fragment_id__.is_some() {
10657 return Err(serde::de::Error::duplicate_field("fragmentId"));
10658 }
10659 fragment_id__ =
10660 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10661 ;
10662 }
10663 GeneratedField::Node => {
10664 if node__.is_some() {
10665 return Err(serde::de::Error::duplicate_field("node"));
10666 }
10667 node__ = map_.next_value()?;
10668 }
10669 GeneratedField::FragmentTypeMask => {
10670 if fragment_type_mask__.is_some() {
10671 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10672 }
10673 fragment_type_mask__ =
10674 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10675 ;
10676 }
10677 GeneratedField::RequiresSingleton => {
10678 if requires_singleton__.is_some() {
10679 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
10680 }
10681 requires_singleton__ = Some(map_.next_value()?);
10682 }
10683 GeneratedField::TableIdsCnt => {
10684 if table_ids_cnt__.is_some() {
10685 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10686 }
10687 table_ids_cnt__ =
10688 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10689 ;
10690 }
10691 GeneratedField::UpstreamTableIds => {
10692 if upstream_table_ids__.is_some() {
10693 return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
10694 }
10695 upstream_table_ids__ =
10696 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10697 .into_iter().map(|x| x.0).collect())
10698 ;
10699 }
10700 }
10701 }
10702 Ok(stream_fragment_graph::StreamFragment {
10703 fragment_id: fragment_id__.unwrap_or_default(),
10704 node: node__,
10705 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10706 requires_singleton: requires_singleton__.unwrap_or_default(),
10707 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10708 upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
10709 })
10710 }
10711 }
10712 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
10713 }
10714}
10715impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
10716 #[allow(deprecated)]
10717 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10718 where
10719 S: serde::Serializer,
10720 {
10721 use serde::ser::SerializeStruct;
10722 let mut len = 0;
10723 if self.dispatch_strategy.is_some() {
10724 len += 1;
10725 }
10726 if self.link_id != 0 {
10727 len += 1;
10728 }
10729 if self.upstream_id != 0 {
10730 len += 1;
10731 }
10732 if self.downstream_id != 0 {
10733 len += 1;
10734 }
10735 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
10736 if let Some(v) = self.dispatch_strategy.as_ref() {
10737 struct_ser.serialize_field("dispatchStrategy", v)?;
10738 }
10739 if self.link_id != 0 {
10740 #[allow(clippy::needless_borrow)]
10741 #[allow(clippy::needless_borrows_for_generic_args)]
10742 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
10743 }
10744 if self.upstream_id != 0 {
10745 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
10746 }
10747 if self.downstream_id != 0 {
10748 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
10749 }
10750 struct_ser.end()
10751 }
10752}
10753impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
10754 #[allow(deprecated)]
10755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10756 where
10757 D: serde::Deserializer<'de>,
10758 {
10759 const FIELDS: &[&str] = &[
10760 "dispatch_strategy",
10761 "dispatchStrategy",
10762 "link_id",
10763 "linkId",
10764 "upstream_id",
10765 "upstreamId",
10766 "downstream_id",
10767 "downstreamId",
10768 ];
10769
10770 #[allow(clippy::enum_variant_names)]
10771 enum GeneratedField {
10772 DispatchStrategy,
10773 LinkId,
10774 UpstreamId,
10775 DownstreamId,
10776 }
10777 impl<'de> serde::Deserialize<'de> for GeneratedField {
10778 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10779 where
10780 D: serde::Deserializer<'de>,
10781 {
10782 struct GeneratedVisitor;
10783
10784 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10785 type Value = GeneratedField;
10786
10787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10788 write!(formatter, "expected one of: {:?}", &FIELDS)
10789 }
10790
10791 #[allow(unused_variables)]
10792 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10793 where
10794 E: serde::de::Error,
10795 {
10796 match value {
10797 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
10798 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
10799 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
10800 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
10801 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10802 }
10803 }
10804 }
10805 deserializer.deserialize_identifier(GeneratedVisitor)
10806 }
10807 }
10808 struct GeneratedVisitor;
10809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10810 type Value = stream_fragment_graph::StreamFragmentEdge;
10811
10812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10813 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
10814 }
10815
10816 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
10817 where
10818 V: serde::de::MapAccess<'de>,
10819 {
10820 let mut dispatch_strategy__ = None;
10821 let mut link_id__ = None;
10822 let mut upstream_id__ = None;
10823 let mut downstream_id__ = None;
10824 while let Some(k) = map_.next_key()? {
10825 match k {
10826 GeneratedField::DispatchStrategy => {
10827 if dispatch_strategy__.is_some() {
10828 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
10829 }
10830 dispatch_strategy__ = map_.next_value()?;
10831 }
10832 GeneratedField::LinkId => {
10833 if link_id__.is_some() {
10834 return Err(serde::de::Error::duplicate_field("linkId"));
10835 }
10836 link_id__ =
10837 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10838 ;
10839 }
10840 GeneratedField::UpstreamId => {
10841 if upstream_id__.is_some() {
10842 return Err(serde::de::Error::duplicate_field("upstreamId"));
10843 }
10844 upstream_id__ =
10845 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10846 ;
10847 }
10848 GeneratedField::DownstreamId => {
10849 if downstream_id__.is_some() {
10850 return Err(serde::de::Error::duplicate_field("downstreamId"));
10851 }
10852 downstream_id__ =
10853 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10854 ;
10855 }
10856 }
10857 }
10858 Ok(stream_fragment_graph::StreamFragmentEdge {
10859 dispatch_strategy: dispatch_strategy__,
10860 link_id: link_id__.unwrap_or_default(),
10861 upstream_id: upstream_id__.unwrap_or_default(),
10862 downstream_id: downstream_id__.unwrap_or_default(),
10863 })
10864 }
10865 }
10866 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
10867 }
10868}
10869impl serde::Serialize for StreamFsFetch {
10870 #[allow(deprecated)]
10871 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10872 where
10873 S: serde::Serializer,
10874 {
10875 use serde::ser::SerializeStruct;
10876 let mut len = 0;
10877 if self.source_id != 0 {
10878 len += 1;
10879 }
10880 if self.state_table.is_some() {
10881 len += 1;
10882 }
10883 if self.row_id_index.is_some() {
10884 len += 1;
10885 }
10886 if !self.columns.is_empty() {
10887 len += 1;
10888 }
10889 if !self.with_properties.is_empty() {
10890 len += 1;
10891 }
10892 if self.info.is_some() {
10893 len += 1;
10894 }
10895 if !self.source_name.is_empty() {
10896 len += 1;
10897 }
10898 if self.rate_limit.is_some() {
10899 len += 1;
10900 }
10901 if !self.secret_refs.is_empty() {
10902 len += 1;
10903 }
10904 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
10905 if self.source_id != 0 {
10906 struct_ser.serialize_field("sourceId", &self.source_id)?;
10907 }
10908 if let Some(v) = self.state_table.as_ref() {
10909 struct_ser.serialize_field("stateTable", v)?;
10910 }
10911 if let Some(v) = self.row_id_index.as_ref() {
10912 struct_ser.serialize_field("rowIdIndex", v)?;
10913 }
10914 if !self.columns.is_empty() {
10915 struct_ser.serialize_field("columns", &self.columns)?;
10916 }
10917 if !self.with_properties.is_empty() {
10918 struct_ser.serialize_field("withProperties", &self.with_properties)?;
10919 }
10920 if let Some(v) = self.info.as_ref() {
10921 struct_ser.serialize_field("info", v)?;
10922 }
10923 if !self.source_name.is_empty() {
10924 struct_ser.serialize_field("sourceName", &self.source_name)?;
10925 }
10926 if let Some(v) = self.rate_limit.as_ref() {
10927 struct_ser.serialize_field("rateLimit", v)?;
10928 }
10929 if !self.secret_refs.is_empty() {
10930 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10931 }
10932 struct_ser.end()
10933 }
10934}
10935impl<'de> serde::Deserialize<'de> for StreamFsFetch {
10936 #[allow(deprecated)]
10937 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10938 where
10939 D: serde::Deserializer<'de>,
10940 {
10941 const FIELDS: &[&str] = &[
10942 "source_id",
10943 "sourceId",
10944 "state_table",
10945 "stateTable",
10946 "row_id_index",
10947 "rowIdIndex",
10948 "columns",
10949 "with_properties",
10950 "withProperties",
10951 "info",
10952 "source_name",
10953 "sourceName",
10954 "rate_limit",
10955 "rateLimit",
10956 "secret_refs",
10957 "secretRefs",
10958 ];
10959
10960 #[allow(clippy::enum_variant_names)]
10961 enum GeneratedField {
10962 SourceId,
10963 StateTable,
10964 RowIdIndex,
10965 Columns,
10966 WithProperties,
10967 Info,
10968 SourceName,
10969 RateLimit,
10970 SecretRefs,
10971 }
10972 impl<'de> serde::Deserialize<'de> for GeneratedField {
10973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10974 where
10975 D: serde::Deserializer<'de>,
10976 {
10977 struct GeneratedVisitor;
10978
10979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10980 type Value = GeneratedField;
10981
10982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10983 write!(formatter, "expected one of: {:?}", &FIELDS)
10984 }
10985
10986 #[allow(unused_variables)]
10987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10988 where
10989 E: serde::de::Error,
10990 {
10991 match value {
10992 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
10993 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10994 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10995 "columns" => Ok(GeneratedField::Columns),
10996 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
10997 "info" => Ok(GeneratedField::Info),
10998 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
10999 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11000 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11001 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11002 }
11003 }
11004 }
11005 deserializer.deserialize_identifier(GeneratedVisitor)
11006 }
11007 }
11008 struct GeneratedVisitor;
11009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11010 type Value = StreamFsFetch;
11011
11012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11013 formatter.write_str("struct stream_plan.StreamFsFetch")
11014 }
11015
11016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11017 where
11018 V: serde::de::MapAccess<'de>,
11019 {
11020 let mut source_id__ = None;
11021 let mut state_table__ = None;
11022 let mut row_id_index__ = None;
11023 let mut columns__ = None;
11024 let mut with_properties__ = None;
11025 let mut info__ = None;
11026 let mut source_name__ = None;
11027 let mut rate_limit__ = None;
11028 let mut secret_refs__ = None;
11029 while let Some(k) = map_.next_key()? {
11030 match k {
11031 GeneratedField::SourceId => {
11032 if source_id__.is_some() {
11033 return Err(serde::de::Error::duplicate_field("sourceId"));
11034 }
11035 source_id__ =
11036 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11037 ;
11038 }
11039 GeneratedField::StateTable => {
11040 if state_table__.is_some() {
11041 return Err(serde::de::Error::duplicate_field("stateTable"));
11042 }
11043 state_table__ = map_.next_value()?;
11044 }
11045 GeneratedField::RowIdIndex => {
11046 if row_id_index__.is_some() {
11047 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11048 }
11049 row_id_index__ =
11050 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11051 ;
11052 }
11053 GeneratedField::Columns => {
11054 if columns__.is_some() {
11055 return Err(serde::de::Error::duplicate_field("columns"));
11056 }
11057 columns__ = Some(map_.next_value()?);
11058 }
11059 GeneratedField::WithProperties => {
11060 if with_properties__.is_some() {
11061 return Err(serde::de::Error::duplicate_field("withProperties"));
11062 }
11063 with_properties__ = Some(
11064 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11065 );
11066 }
11067 GeneratedField::Info => {
11068 if info__.is_some() {
11069 return Err(serde::de::Error::duplicate_field("info"));
11070 }
11071 info__ = map_.next_value()?;
11072 }
11073 GeneratedField::SourceName => {
11074 if source_name__.is_some() {
11075 return Err(serde::de::Error::duplicate_field("sourceName"));
11076 }
11077 source_name__ = Some(map_.next_value()?);
11078 }
11079 GeneratedField::RateLimit => {
11080 if rate_limit__.is_some() {
11081 return Err(serde::de::Error::duplicate_field("rateLimit"));
11082 }
11083 rate_limit__ =
11084 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11085 ;
11086 }
11087 GeneratedField::SecretRefs => {
11088 if secret_refs__.is_some() {
11089 return Err(serde::de::Error::duplicate_field("secretRefs"));
11090 }
11091 secret_refs__ = Some(
11092 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11093 );
11094 }
11095 }
11096 }
11097 Ok(StreamFsFetch {
11098 source_id: source_id__.unwrap_or_default(),
11099 state_table: state_table__,
11100 row_id_index: row_id_index__,
11101 columns: columns__.unwrap_or_default(),
11102 with_properties: with_properties__.unwrap_or_default(),
11103 info: info__,
11104 source_name: source_name__.unwrap_or_default(),
11105 rate_limit: rate_limit__,
11106 secret_refs: secret_refs__.unwrap_or_default(),
11107 })
11108 }
11109 }
11110 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11111 }
11112}
11113impl serde::Serialize for StreamFsFetchNode {
11114 #[allow(deprecated)]
11115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11116 where
11117 S: serde::Serializer,
11118 {
11119 use serde::ser::SerializeStruct;
11120 let mut len = 0;
11121 if self.node_inner.is_some() {
11122 len += 1;
11123 }
11124 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11125 if let Some(v) = self.node_inner.as_ref() {
11126 struct_ser.serialize_field("nodeInner", v)?;
11127 }
11128 struct_ser.end()
11129 }
11130}
11131impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11132 #[allow(deprecated)]
11133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11134 where
11135 D: serde::Deserializer<'de>,
11136 {
11137 const FIELDS: &[&str] = &[
11138 "node_inner",
11139 "nodeInner",
11140 ];
11141
11142 #[allow(clippy::enum_variant_names)]
11143 enum GeneratedField {
11144 NodeInner,
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 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11167 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11168 }
11169 }
11170 }
11171 deserializer.deserialize_identifier(GeneratedVisitor)
11172 }
11173 }
11174 struct GeneratedVisitor;
11175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11176 type Value = StreamFsFetchNode;
11177
11178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11179 formatter.write_str("struct stream_plan.StreamFsFetchNode")
11180 }
11181
11182 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11183 where
11184 V: serde::de::MapAccess<'de>,
11185 {
11186 let mut node_inner__ = None;
11187 while let Some(k) = map_.next_key()? {
11188 match k {
11189 GeneratedField::NodeInner => {
11190 if node_inner__.is_some() {
11191 return Err(serde::de::Error::duplicate_field("nodeInner"));
11192 }
11193 node_inner__ = map_.next_value()?;
11194 }
11195 }
11196 }
11197 Ok(StreamFsFetchNode {
11198 node_inner: node_inner__,
11199 })
11200 }
11201 }
11202 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11203 }
11204}
11205impl serde::Serialize for StreamMessage {
11206 #[allow(deprecated)]
11207 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11208 where
11209 S: serde::Serializer,
11210 {
11211 use serde::ser::SerializeStruct;
11212 let mut len = 0;
11213 if self.stream_message.is_some() {
11214 len += 1;
11215 }
11216 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11217 if let Some(v) = self.stream_message.as_ref() {
11218 match v {
11219 stream_message::StreamMessage::StreamChunk(v) => {
11220 struct_ser.serialize_field("streamChunk", v)?;
11221 }
11222 stream_message::StreamMessage::Barrier(v) => {
11223 struct_ser.serialize_field("barrier", v)?;
11224 }
11225 stream_message::StreamMessage::Watermark(v) => {
11226 struct_ser.serialize_field("watermark", v)?;
11227 }
11228 }
11229 }
11230 struct_ser.end()
11231 }
11232}
11233impl<'de> serde::Deserialize<'de> for StreamMessage {
11234 #[allow(deprecated)]
11235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11236 where
11237 D: serde::Deserializer<'de>,
11238 {
11239 const FIELDS: &[&str] = &[
11240 "stream_chunk",
11241 "streamChunk",
11242 "barrier",
11243 "watermark",
11244 ];
11245
11246 #[allow(clippy::enum_variant_names)]
11247 enum GeneratedField {
11248 StreamChunk,
11249 Barrier,
11250 Watermark,
11251 }
11252 impl<'de> serde::Deserialize<'de> for GeneratedField {
11253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11254 where
11255 D: serde::Deserializer<'de>,
11256 {
11257 struct GeneratedVisitor;
11258
11259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11260 type Value = GeneratedField;
11261
11262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11263 write!(formatter, "expected one of: {:?}", &FIELDS)
11264 }
11265
11266 #[allow(unused_variables)]
11267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11268 where
11269 E: serde::de::Error,
11270 {
11271 match value {
11272 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11273 "barrier" => Ok(GeneratedField::Barrier),
11274 "watermark" => Ok(GeneratedField::Watermark),
11275 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11276 }
11277 }
11278 }
11279 deserializer.deserialize_identifier(GeneratedVisitor)
11280 }
11281 }
11282 struct GeneratedVisitor;
11283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11284 type Value = StreamMessage;
11285
11286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11287 formatter.write_str("struct stream_plan.StreamMessage")
11288 }
11289
11290 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
11291 where
11292 V: serde::de::MapAccess<'de>,
11293 {
11294 let mut stream_message__ = None;
11295 while let Some(k) = map_.next_key()? {
11296 match k {
11297 GeneratedField::StreamChunk => {
11298 if stream_message__.is_some() {
11299 return Err(serde::de::Error::duplicate_field("streamChunk"));
11300 }
11301 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
11302;
11303 }
11304 GeneratedField::Barrier => {
11305 if stream_message__.is_some() {
11306 return Err(serde::de::Error::duplicate_field("barrier"));
11307 }
11308 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
11309;
11310 }
11311 GeneratedField::Watermark => {
11312 if stream_message__.is_some() {
11313 return Err(serde::de::Error::duplicate_field("watermark"));
11314 }
11315 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
11316;
11317 }
11318 }
11319 }
11320 Ok(StreamMessage {
11321 stream_message: stream_message__,
11322 })
11323 }
11324 }
11325 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
11326 }
11327}
11328impl serde::Serialize for StreamMessageBatch {
11329 #[allow(deprecated)]
11330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11331 where
11332 S: serde::Serializer,
11333 {
11334 use serde::ser::SerializeStruct;
11335 let mut len = 0;
11336 if self.stream_message_batch.is_some() {
11337 len += 1;
11338 }
11339 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
11340 if let Some(v) = self.stream_message_batch.as_ref() {
11341 match v {
11342 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
11343 struct_ser.serialize_field("streamChunk", v)?;
11344 }
11345 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
11346 struct_ser.serialize_field("barrierBatch", v)?;
11347 }
11348 stream_message_batch::StreamMessageBatch::Watermark(v) => {
11349 struct_ser.serialize_field("watermark", v)?;
11350 }
11351 }
11352 }
11353 struct_ser.end()
11354 }
11355}
11356impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
11357 #[allow(deprecated)]
11358 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11359 where
11360 D: serde::Deserializer<'de>,
11361 {
11362 const FIELDS: &[&str] = &[
11363 "stream_chunk",
11364 "streamChunk",
11365 "barrier_batch",
11366 "barrierBatch",
11367 "watermark",
11368 ];
11369
11370 #[allow(clippy::enum_variant_names)]
11371 enum GeneratedField {
11372 StreamChunk,
11373 BarrierBatch,
11374 Watermark,
11375 }
11376 impl<'de> serde::Deserialize<'de> for GeneratedField {
11377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11378 where
11379 D: serde::Deserializer<'de>,
11380 {
11381 struct GeneratedVisitor;
11382
11383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11384 type Value = GeneratedField;
11385
11386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11387 write!(formatter, "expected one of: {:?}", &FIELDS)
11388 }
11389
11390 #[allow(unused_variables)]
11391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11392 where
11393 E: serde::de::Error,
11394 {
11395 match value {
11396 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11397 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
11398 "watermark" => Ok(GeneratedField::Watermark),
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 = StreamMessageBatch;
11409
11410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11411 formatter.write_str("struct stream_plan.StreamMessageBatch")
11412 }
11413
11414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
11415 where
11416 V: serde::de::MapAccess<'de>,
11417 {
11418 let mut stream_message_batch__ = None;
11419 while let Some(k) = map_.next_key()? {
11420 match k {
11421 GeneratedField::StreamChunk => {
11422 if stream_message_batch__.is_some() {
11423 return Err(serde::de::Error::duplicate_field("streamChunk"));
11424 }
11425 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
11426;
11427 }
11428 GeneratedField::BarrierBatch => {
11429 if stream_message_batch__.is_some() {
11430 return Err(serde::de::Error::duplicate_field("barrierBatch"));
11431 }
11432 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
11433;
11434 }
11435 GeneratedField::Watermark => {
11436 if stream_message_batch__.is_some() {
11437 return Err(serde::de::Error::duplicate_field("watermark"));
11438 }
11439 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
11440;
11441 }
11442 }
11443 }
11444 Ok(StreamMessageBatch {
11445 stream_message_batch: stream_message_batch__,
11446 })
11447 }
11448 }
11449 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
11450 }
11451}
11452impl serde::Serialize for stream_message_batch::BarrierBatch {
11453 #[allow(deprecated)]
11454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11455 where
11456 S: serde::Serializer,
11457 {
11458 use serde::ser::SerializeStruct;
11459 let mut len = 0;
11460 if !self.barriers.is_empty() {
11461 len += 1;
11462 }
11463 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
11464 if !self.barriers.is_empty() {
11465 struct_ser.serialize_field("barriers", &self.barriers)?;
11466 }
11467 struct_ser.end()
11468 }
11469}
11470impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
11471 #[allow(deprecated)]
11472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11473 where
11474 D: serde::Deserializer<'de>,
11475 {
11476 const FIELDS: &[&str] = &[
11477 "barriers",
11478 ];
11479
11480 #[allow(clippy::enum_variant_names)]
11481 enum GeneratedField {
11482 Barriers,
11483 }
11484 impl<'de> serde::Deserialize<'de> for GeneratedField {
11485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11486 where
11487 D: serde::Deserializer<'de>,
11488 {
11489 struct GeneratedVisitor;
11490
11491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11492 type Value = GeneratedField;
11493
11494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11495 write!(formatter, "expected one of: {:?}", &FIELDS)
11496 }
11497
11498 #[allow(unused_variables)]
11499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11500 where
11501 E: serde::de::Error,
11502 {
11503 match value {
11504 "barriers" => Ok(GeneratedField::Barriers),
11505 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11506 }
11507 }
11508 }
11509 deserializer.deserialize_identifier(GeneratedVisitor)
11510 }
11511 }
11512 struct GeneratedVisitor;
11513 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11514 type Value = stream_message_batch::BarrierBatch;
11515
11516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11517 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
11518 }
11519
11520 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
11521 where
11522 V: serde::de::MapAccess<'de>,
11523 {
11524 let mut barriers__ = None;
11525 while let Some(k) = map_.next_key()? {
11526 match k {
11527 GeneratedField::Barriers => {
11528 if barriers__.is_some() {
11529 return Err(serde::de::Error::duplicate_field("barriers"));
11530 }
11531 barriers__ = Some(map_.next_value()?);
11532 }
11533 }
11534 }
11535 Ok(stream_message_batch::BarrierBatch {
11536 barriers: barriers__.unwrap_or_default(),
11537 })
11538 }
11539 }
11540 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
11541 }
11542}
11543impl serde::Serialize for StreamNode {
11544 #[allow(deprecated)]
11545 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11546 where
11547 S: serde::Serializer,
11548 {
11549 use serde::ser::SerializeStruct;
11550 let mut len = 0;
11551 if self.operator_id != 0 {
11552 len += 1;
11553 }
11554 if !self.input.is_empty() {
11555 len += 1;
11556 }
11557 if !self.stream_key.is_empty() {
11558 len += 1;
11559 }
11560 if self.append_only {
11561 len += 1;
11562 }
11563 if !self.identity.is_empty() {
11564 len += 1;
11565 }
11566 if !self.fields.is_empty() {
11567 len += 1;
11568 }
11569 if self.node_body.is_some() {
11570 len += 1;
11571 }
11572 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
11573 if self.operator_id != 0 {
11574 #[allow(clippy::needless_borrow)]
11575 #[allow(clippy::needless_borrows_for_generic_args)]
11576 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
11577 }
11578 if !self.input.is_empty() {
11579 struct_ser.serialize_field("input", &self.input)?;
11580 }
11581 if !self.stream_key.is_empty() {
11582 struct_ser.serialize_field("streamKey", &self.stream_key)?;
11583 }
11584 if self.append_only {
11585 struct_ser.serialize_field("appendOnly", &self.append_only)?;
11586 }
11587 if !self.identity.is_empty() {
11588 struct_ser.serialize_field("identity", &self.identity)?;
11589 }
11590 if !self.fields.is_empty() {
11591 struct_ser.serialize_field("fields", &self.fields)?;
11592 }
11593 if let Some(v) = self.node_body.as_ref() {
11594 match v {
11595 stream_node::NodeBody::Source(v) => {
11596 struct_ser.serialize_field("source", v)?;
11597 }
11598 stream_node::NodeBody::Project(v) => {
11599 struct_ser.serialize_field("project", v)?;
11600 }
11601 stream_node::NodeBody::Filter(v) => {
11602 struct_ser.serialize_field("filter", v)?;
11603 }
11604 stream_node::NodeBody::Materialize(v) => {
11605 struct_ser.serialize_field("materialize", v)?;
11606 }
11607 stream_node::NodeBody::StatelessSimpleAgg(v) => {
11608 struct_ser.serialize_field("statelessSimpleAgg", v)?;
11609 }
11610 stream_node::NodeBody::SimpleAgg(v) => {
11611 struct_ser.serialize_field("simpleAgg", v)?;
11612 }
11613 stream_node::NodeBody::HashAgg(v) => {
11614 struct_ser.serialize_field("hashAgg", v)?;
11615 }
11616 stream_node::NodeBody::AppendOnlyTopN(v) => {
11617 struct_ser.serialize_field("appendOnlyTopN", v)?;
11618 }
11619 stream_node::NodeBody::HashJoin(v) => {
11620 struct_ser.serialize_field("hashJoin", v)?;
11621 }
11622 stream_node::NodeBody::TopN(v) => {
11623 struct_ser.serialize_field("topN", v)?;
11624 }
11625 stream_node::NodeBody::HopWindow(v) => {
11626 struct_ser.serialize_field("hopWindow", v)?;
11627 }
11628 stream_node::NodeBody::Merge(v) => {
11629 struct_ser.serialize_field("merge", v)?;
11630 }
11631 stream_node::NodeBody::Exchange(v) => {
11632 struct_ser.serialize_field("exchange", v)?;
11633 }
11634 stream_node::NodeBody::StreamScan(v) => {
11635 struct_ser.serialize_field("streamScan", v)?;
11636 }
11637 stream_node::NodeBody::BatchPlan(v) => {
11638 struct_ser.serialize_field("batchPlan", v)?;
11639 }
11640 stream_node::NodeBody::Lookup(v) => {
11641 struct_ser.serialize_field("lookup", v)?;
11642 }
11643 stream_node::NodeBody::Arrange(v) => {
11644 struct_ser.serialize_field("arrange", v)?;
11645 }
11646 stream_node::NodeBody::LookupUnion(v) => {
11647 struct_ser.serialize_field("lookupUnion", v)?;
11648 }
11649 stream_node::NodeBody::Union(v) => {
11650 struct_ser.serialize_field("union", v)?;
11651 }
11652 stream_node::NodeBody::DeltaIndexJoin(v) => {
11653 struct_ser.serialize_field("deltaIndexJoin", v)?;
11654 }
11655 stream_node::NodeBody::Sink(v) => {
11656 struct_ser.serialize_field("sink", v)?;
11657 }
11658 stream_node::NodeBody::Expand(v) => {
11659 struct_ser.serialize_field("expand", v)?;
11660 }
11661 stream_node::NodeBody::DynamicFilter(v) => {
11662 struct_ser.serialize_field("dynamicFilter", v)?;
11663 }
11664 stream_node::NodeBody::ProjectSet(v) => {
11665 struct_ser.serialize_field("projectSet", v)?;
11666 }
11667 stream_node::NodeBody::GroupTopN(v) => {
11668 struct_ser.serialize_field("groupTopN", v)?;
11669 }
11670 stream_node::NodeBody::Sort(v) => {
11671 struct_ser.serialize_field("sort", v)?;
11672 }
11673 stream_node::NodeBody::WatermarkFilter(v) => {
11674 struct_ser.serialize_field("watermarkFilter", v)?;
11675 }
11676 stream_node::NodeBody::Dml(v) => {
11677 struct_ser.serialize_field("dml", v)?;
11678 }
11679 stream_node::NodeBody::RowIdGen(v) => {
11680 struct_ser.serialize_field("rowIdGen", v)?;
11681 }
11682 stream_node::NodeBody::Now(v) => {
11683 struct_ser.serialize_field("now", v)?;
11684 }
11685 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
11686 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
11687 }
11688 stream_node::NodeBody::TemporalJoin(v) => {
11689 struct_ser.serialize_field("temporalJoin", v)?;
11690 }
11691 stream_node::NodeBody::BarrierRecv(v) => {
11692 struct_ser.serialize_field("barrierRecv", v)?;
11693 }
11694 stream_node::NodeBody::Values(v) => {
11695 struct_ser.serialize_field("values", v)?;
11696 }
11697 stream_node::NodeBody::AppendOnlyDedup(v) => {
11698 struct_ser.serialize_field("appendOnlyDedup", v)?;
11699 }
11700 stream_node::NodeBody::NoOp(v) => {
11701 struct_ser.serialize_field("noOp", v)?;
11702 }
11703 stream_node::NodeBody::EowcOverWindow(v) => {
11704 struct_ser.serialize_field("eowcOverWindow", v)?;
11705 }
11706 stream_node::NodeBody::OverWindow(v) => {
11707 struct_ser.serialize_field("overWindow", v)?;
11708 }
11709 stream_node::NodeBody::StreamFsFetch(v) => {
11710 struct_ser.serialize_field("streamFsFetch", v)?;
11711 }
11712 stream_node::NodeBody::StreamCdcScan(v) => {
11713 struct_ser.serialize_field("streamCdcScan", v)?;
11714 }
11715 stream_node::NodeBody::CdcFilter(v) => {
11716 struct_ser.serialize_field("cdcFilter", v)?;
11717 }
11718 stream_node::NodeBody::SourceBackfill(v) => {
11719 struct_ser.serialize_field("sourceBackfill", v)?;
11720 }
11721 stream_node::NodeBody::Changelog(v) => {
11722 struct_ser.serialize_field("changelog", v)?;
11723 }
11724 stream_node::NodeBody::LocalApproxPercentile(v) => {
11725 struct_ser.serialize_field("localApproxPercentile", v)?;
11726 }
11727 stream_node::NodeBody::GlobalApproxPercentile(v) => {
11728 struct_ser.serialize_field("globalApproxPercentile", v)?;
11729 }
11730 stream_node::NodeBody::RowMerge(v) => {
11731 struct_ser.serialize_field("rowMerge", v)?;
11732 }
11733 stream_node::NodeBody::AsOfJoin(v) => {
11734 struct_ser.serialize_field("asOfJoin", v)?;
11735 }
11736 stream_node::NodeBody::SyncLogStore(v) => {
11737 struct_ser.serialize_field("syncLogStore", v)?;
11738 }
11739 stream_node::NodeBody::MaterializedExprs(v) => {
11740 struct_ser.serialize_field("materializedExprs", v)?;
11741 }
11742 }
11743 }
11744 struct_ser.end()
11745 }
11746}
11747impl<'de> serde::Deserialize<'de> for StreamNode {
11748 #[allow(deprecated)]
11749 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11750 where
11751 D: serde::Deserializer<'de>,
11752 {
11753 const FIELDS: &[&str] = &[
11754 "operator_id",
11755 "operatorId",
11756 "input",
11757 "stream_key",
11758 "streamKey",
11759 "append_only",
11760 "appendOnly",
11761 "identity",
11762 "fields",
11763 "source",
11764 "project",
11765 "filter",
11766 "materialize",
11767 "stateless_simple_agg",
11768 "statelessSimpleAgg",
11769 "simple_agg",
11770 "simpleAgg",
11771 "hash_agg",
11772 "hashAgg",
11773 "append_only_top_n",
11774 "appendOnlyTopN",
11775 "hash_join",
11776 "hashJoin",
11777 "top_n",
11778 "topN",
11779 "hop_window",
11780 "hopWindow",
11781 "merge",
11782 "exchange",
11783 "stream_scan",
11784 "streamScan",
11785 "batch_plan",
11786 "batchPlan",
11787 "lookup",
11788 "arrange",
11789 "lookup_union",
11790 "lookupUnion",
11791 "union",
11792 "delta_index_join",
11793 "deltaIndexJoin",
11794 "sink",
11795 "expand",
11796 "dynamic_filter",
11797 "dynamicFilter",
11798 "project_set",
11799 "projectSet",
11800 "group_top_n",
11801 "groupTopN",
11802 "sort",
11803 "watermark_filter",
11804 "watermarkFilter",
11805 "dml",
11806 "row_id_gen",
11807 "rowIdGen",
11808 "now",
11809 "append_only_group_top_n",
11810 "appendOnlyGroupTopN",
11811 "temporal_join",
11812 "temporalJoin",
11813 "barrier_recv",
11814 "barrierRecv",
11815 "values",
11816 "append_only_dedup",
11817 "appendOnlyDedup",
11818 "no_op",
11819 "noOp",
11820 "eowc_over_window",
11821 "eowcOverWindow",
11822 "over_window",
11823 "overWindow",
11824 "stream_fs_fetch",
11825 "streamFsFetch",
11826 "stream_cdc_scan",
11827 "streamCdcScan",
11828 "cdc_filter",
11829 "cdcFilter",
11830 "source_backfill",
11831 "sourceBackfill",
11832 "changelog",
11833 "local_approx_percentile",
11834 "localApproxPercentile",
11835 "global_approx_percentile",
11836 "globalApproxPercentile",
11837 "row_merge",
11838 "rowMerge",
11839 "as_of_join",
11840 "asOfJoin",
11841 "sync_log_store",
11842 "syncLogStore",
11843 "materialized_exprs",
11844 "materializedExprs",
11845 ];
11846
11847 #[allow(clippy::enum_variant_names)]
11848 enum GeneratedField {
11849 OperatorId,
11850 Input,
11851 StreamKey,
11852 AppendOnly,
11853 Identity,
11854 Fields,
11855 Source,
11856 Project,
11857 Filter,
11858 Materialize,
11859 StatelessSimpleAgg,
11860 SimpleAgg,
11861 HashAgg,
11862 AppendOnlyTopN,
11863 HashJoin,
11864 TopN,
11865 HopWindow,
11866 Merge,
11867 Exchange,
11868 StreamScan,
11869 BatchPlan,
11870 Lookup,
11871 Arrange,
11872 LookupUnion,
11873 Union,
11874 DeltaIndexJoin,
11875 Sink,
11876 Expand,
11877 DynamicFilter,
11878 ProjectSet,
11879 GroupTopN,
11880 Sort,
11881 WatermarkFilter,
11882 Dml,
11883 RowIdGen,
11884 Now,
11885 AppendOnlyGroupTopN,
11886 TemporalJoin,
11887 BarrierRecv,
11888 Values,
11889 AppendOnlyDedup,
11890 NoOp,
11891 EowcOverWindow,
11892 OverWindow,
11893 StreamFsFetch,
11894 StreamCdcScan,
11895 CdcFilter,
11896 SourceBackfill,
11897 Changelog,
11898 LocalApproxPercentile,
11899 GlobalApproxPercentile,
11900 RowMerge,
11901 AsOfJoin,
11902 SyncLogStore,
11903 MaterializedExprs,
11904 }
11905 impl<'de> serde::Deserialize<'de> for GeneratedField {
11906 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11907 where
11908 D: serde::Deserializer<'de>,
11909 {
11910 struct GeneratedVisitor;
11911
11912 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11913 type Value = GeneratedField;
11914
11915 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11916 write!(formatter, "expected one of: {:?}", &FIELDS)
11917 }
11918
11919 #[allow(unused_variables)]
11920 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11921 where
11922 E: serde::de::Error,
11923 {
11924 match value {
11925 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
11926 "input" => Ok(GeneratedField::Input),
11927 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
11928 "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
11929 "identity" => Ok(GeneratedField::Identity),
11930 "fields" => Ok(GeneratedField::Fields),
11931 "source" => Ok(GeneratedField::Source),
11932 "project" => Ok(GeneratedField::Project),
11933 "filter" => Ok(GeneratedField::Filter),
11934 "materialize" => Ok(GeneratedField::Materialize),
11935 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
11936 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
11937 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
11938 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
11939 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
11940 "topN" | "top_n" => Ok(GeneratedField::TopN),
11941 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
11942 "merge" => Ok(GeneratedField::Merge),
11943 "exchange" => Ok(GeneratedField::Exchange),
11944 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
11945 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
11946 "lookup" => Ok(GeneratedField::Lookup),
11947 "arrange" => Ok(GeneratedField::Arrange),
11948 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
11949 "union" => Ok(GeneratedField::Union),
11950 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
11951 "sink" => Ok(GeneratedField::Sink),
11952 "expand" => Ok(GeneratedField::Expand),
11953 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
11954 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
11955 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
11956 "sort" => Ok(GeneratedField::Sort),
11957 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
11958 "dml" => Ok(GeneratedField::Dml),
11959 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
11960 "now" => Ok(GeneratedField::Now),
11961 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
11962 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
11963 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
11964 "values" => Ok(GeneratedField::Values),
11965 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
11966 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
11967 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
11968 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
11969 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
11970 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
11971 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
11972 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
11973 "changelog" => Ok(GeneratedField::Changelog),
11974 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
11975 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
11976 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
11977 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
11978 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
11979 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
11980 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11981 }
11982 }
11983 }
11984 deserializer.deserialize_identifier(GeneratedVisitor)
11985 }
11986 }
11987 struct GeneratedVisitor;
11988 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11989 type Value = StreamNode;
11990
11991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11992 formatter.write_str("struct stream_plan.StreamNode")
11993 }
11994
11995 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
11996 where
11997 V: serde::de::MapAccess<'de>,
11998 {
11999 let mut operator_id__ = None;
12000 let mut input__ = None;
12001 let mut stream_key__ = None;
12002 let mut append_only__ = None;
12003 let mut identity__ = None;
12004 let mut fields__ = None;
12005 let mut node_body__ = None;
12006 while let Some(k) = map_.next_key()? {
12007 match k {
12008 GeneratedField::OperatorId => {
12009 if operator_id__.is_some() {
12010 return Err(serde::de::Error::duplicate_field("operatorId"));
12011 }
12012 operator_id__ =
12013 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12014 ;
12015 }
12016 GeneratedField::Input => {
12017 if input__.is_some() {
12018 return Err(serde::de::Error::duplicate_field("input"));
12019 }
12020 input__ = Some(map_.next_value()?);
12021 }
12022 GeneratedField::StreamKey => {
12023 if stream_key__.is_some() {
12024 return Err(serde::de::Error::duplicate_field("streamKey"));
12025 }
12026 stream_key__ =
12027 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12028 .into_iter().map(|x| x.0).collect())
12029 ;
12030 }
12031 GeneratedField::AppendOnly => {
12032 if append_only__.is_some() {
12033 return Err(serde::de::Error::duplicate_field("appendOnly"));
12034 }
12035 append_only__ = Some(map_.next_value()?);
12036 }
12037 GeneratedField::Identity => {
12038 if identity__.is_some() {
12039 return Err(serde::de::Error::duplicate_field("identity"));
12040 }
12041 identity__ = Some(map_.next_value()?);
12042 }
12043 GeneratedField::Fields => {
12044 if fields__.is_some() {
12045 return Err(serde::de::Error::duplicate_field("fields"));
12046 }
12047 fields__ = Some(map_.next_value()?);
12048 }
12049 GeneratedField::Source => {
12050 if node_body__.is_some() {
12051 return Err(serde::de::Error::duplicate_field("source"));
12052 }
12053 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12054;
12055 }
12056 GeneratedField::Project => {
12057 if node_body__.is_some() {
12058 return Err(serde::de::Error::duplicate_field("project"));
12059 }
12060 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12061;
12062 }
12063 GeneratedField::Filter => {
12064 if node_body__.is_some() {
12065 return Err(serde::de::Error::duplicate_field("filter"));
12066 }
12067 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12068;
12069 }
12070 GeneratedField::Materialize => {
12071 if node_body__.is_some() {
12072 return Err(serde::de::Error::duplicate_field("materialize"));
12073 }
12074 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12075;
12076 }
12077 GeneratedField::StatelessSimpleAgg => {
12078 if node_body__.is_some() {
12079 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12080 }
12081 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12082;
12083 }
12084 GeneratedField::SimpleAgg => {
12085 if node_body__.is_some() {
12086 return Err(serde::de::Error::duplicate_field("simpleAgg"));
12087 }
12088 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12089;
12090 }
12091 GeneratedField::HashAgg => {
12092 if node_body__.is_some() {
12093 return Err(serde::de::Error::duplicate_field("hashAgg"));
12094 }
12095 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12096;
12097 }
12098 GeneratedField::AppendOnlyTopN => {
12099 if node_body__.is_some() {
12100 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12101 }
12102 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12103;
12104 }
12105 GeneratedField::HashJoin => {
12106 if node_body__.is_some() {
12107 return Err(serde::de::Error::duplicate_field("hashJoin"));
12108 }
12109 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12110;
12111 }
12112 GeneratedField::TopN => {
12113 if node_body__.is_some() {
12114 return Err(serde::de::Error::duplicate_field("topN"));
12115 }
12116 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12117;
12118 }
12119 GeneratedField::HopWindow => {
12120 if node_body__.is_some() {
12121 return Err(serde::de::Error::duplicate_field("hopWindow"));
12122 }
12123 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12124;
12125 }
12126 GeneratedField::Merge => {
12127 if node_body__.is_some() {
12128 return Err(serde::de::Error::duplicate_field("merge"));
12129 }
12130 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12131;
12132 }
12133 GeneratedField::Exchange => {
12134 if node_body__.is_some() {
12135 return Err(serde::de::Error::duplicate_field("exchange"));
12136 }
12137 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12138;
12139 }
12140 GeneratedField::StreamScan => {
12141 if node_body__.is_some() {
12142 return Err(serde::de::Error::duplicate_field("streamScan"));
12143 }
12144 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12145;
12146 }
12147 GeneratedField::BatchPlan => {
12148 if node_body__.is_some() {
12149 return Err(serde::de::Error::duplicate_field("batchPlan"));
12150 }
12151 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12152;
12153 }
12154 GeneratedField::Lookup => {
12155 if node_body__.is_some() {
12156 return Err(serde::de::Error::duplicate_field("lookup"));
12157 }
12158 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12159;
12160 }
12161 GeneratedField::Arrange => {
12162 if node_body__.is_some() {
12163 return Err(serde::de::Error::duplicate_field("arrange"));
12164 }
12165 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12166;
12167 }
12168 GeneratedField::LookupUnion => {
12169 if node_body__.is_some() {
12170 return Err(serde::de::Error::duplicate_field("lookupUnion"));
12171 }
12172 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12173;
12174 }
12175 GeneratedField::Union => {
12176 if node_body__.is_some() {
12177 return Err(serde::de::Error::duplicate_field("union"));
12178 }
12179 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12180;
12181 }
12182 GeneratedField::DeltaIndexJoin => {
12183 if node_body__.is_some() {
12184 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12185 }
12186 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12187;
12188 }
12189 GeneratedField::Sink => {
12190 if node_body__.is_some() {
12191 return Err(serde::de::Error::duplicate_field("sink"));
12192 }
12193 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12194;
12195 }
12196 GeneratedField::Expand => {
12197 if node_body__.is_some() {
12198 return Err(serde::de::Error::duplicate_field("expand"));
12199 }
12200 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12201;
12202 }
12203 GeneratedField::DynamicFilter => {
12204 if node_body__.is_some() {
12205 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12206 }
12207 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12208;
12209 }
12210 GeneratedField::ProjectSet => {
12211 if node_body__.is_some() {
12212 return Err(serde::de::Error::duplicate_field("projectSet"));
12213 }
12214 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12215;
12216 }
12217 GeneratedField::GroupTopN => {
12218 if node_body__.is_some() {
12219 return Err(serde::de::Error::duplicate_field("groupTopN"));
12220 }
12221 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12222;
12223 }
12224 GeneratedField::Sort => {
12225 if node_body__.is_some() {
12226 return Err(serde::de::Error::duplicate_field("sort"));
12227 }
12228 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12229;
12230 }
12231 GeneratedField::WatermarkFilter => {
12232 if node_body__.is_some() {
12233 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12234 }
12235 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12236;
12237 }
12238 GeneratedField::Dml => {
12239 if node_body__.is_some() {
12240 return Err(serde::de::Error::duplicate_field("dml"));
12241 }
12242 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12243;
12244 }
12245 GeneratedField::RowIdGen => {
12246 if node_body__.is_some() {
12247 return Err(serde::de::Error::duplicate_field("rowIdGen"));
12248 }
12249 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12250;
12251 }
12252 GeneratedField::Now => {
12253 if node_body__.is_some() {
12254 return Err(serde::de::Error::duplicate_field("now"));
12255 }
12256 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12257;
12258 }
12259 GeneratedField::AppendOnlyGroupTopN => {
12260 if node_body__.is_some() {
12261 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
12262 }
12263 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
12264;
12265 }
12266 GeneratedField::TemporalJoin => {
12267 if node_body__.is_some() {
12268 return Err(serde::de::Error::duplicate_field("temporalJoin"));
12269 }
12270 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
12271;
12272 }
12273 GeneratedField::BarrierRecv => {
12274 if node_body__.is_some() {
12275 return Err(serde::de::Error::duplicate_field("barrierRecv"));
12276 }
12277 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
12278;
12279 }
12280 GeneratedField::Values => {
12281 if node_body__.is_some() {
12282 return Err(serde::de::Error::duplicate_field("values"));
12283 }
12284 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
12285;
12286 }
12287 GeneratedField::AppendOnlyDedup => {
12288 if node_body__.is_some() {
12289 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
12290 }
12291 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
12292;
12293 }
12294 GeneratedField::NoOp => {
12295 if node_body__.is_some() {
12296 return Err(serde::de::Error::duplicate_field("noOp"));
12297 }
12298 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
12299;
12300 }
12301 GeneratedField::EowcOverWindow => {
12302 if node_body__.is_some() {
12303 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
12304 }
12305 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
12306;
12307 }
12308 GeneratedField::OverWindow => {
12309 if node_body__.is_some() {
12310 return Err(serde::de::Error::duplicate_field("overWindow"));
12311 }
12312 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
12313;
12314 }
12315 GeneratedField::StreamFsFetch => {
12316 if node_body__.is_some() {
12317 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
12318 }
12319 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
12320;
12321 }
12322 GeneratedField::StreamCdcScan => {
12323 if node_body__.is_some() {
12324 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
12325 }
12326 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
12327;
12328 }
12329 GeneratedField::CdcFilter => {
12330 if node_body__.is_some() {
12331 return Err(serde::de::Error::duplicate_field("cdcFilter"));
12332 }
12333 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
12334;
12335 }
12336 GeneratedField::SourceBackfill => {
12337 if node_body__.is_some() {
12338 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
12339 }
12340 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
12341;
12342 }
12343 GeneratedField::Changelog => {
12344 if node_body__.is_some() {
12345 return Err(serde::de::Error::duplicate_field("changelog"));
12346 }
12347 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
12348;
12349 }
12350 GeneratedField::LocalApproxPercentile => {
12351 if node_body__.is_some() {
12352 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
12353 }
12354 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
12355;
12356 }
12357 GeneratedField::GlobalApproxPercentile => {
12358 if node_body__.is_some() {
12359 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
12360 }
12361 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
12362;
12363 }
12364 GeneratedField::RowMerge => {
12365 if node_body__.is_some() {
12366 return Err(serde::de::Error::duplicate_field("rowMerge"));
12367 }
12368 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
12369;
12370 }
12371 GeneratedField::AsOfJoin => {
12372 if node_body__.is_some() {
12373 return Err(serde::de::Error::duplicate_field("asOfJoin"));
12374 }
12375 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
12376;
12377 }
12378 GeneratedField::SyncLogStore => {
12379 if node_body__.is_some() {
12380 return Err(serde::de::Error::duplicate_field("syncLogStore"));
12381 }
12382 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
12383;
12384 }
12385 GeneratedField::MaterializedExprs => {
12386 if node_body__.is_some() {
12387 return Err(serde::de::Error::duplicate_field("materializedExprs"));
12388 }
12389 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
12390;
12391 }
12392 }
12393 }
12394 Ok(StreamNode {
12395 operator_id: operator_id__.unwrap_or_default(),
12396 input: input__.unwrap_or_default(),
12397 stream_key: stream_key__.unwrap_or_default(),
12398 append_only: append_only__.unwrap_or_default(),
12399 identity: identity__.unwrap_or_default(),
12400 fields: fields__.unwrap_or_default(),
12401 node_body: node_body__,
12402 })
12403 }
12404 }
12405 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
12406 }
12407}
12408impl serde::Serialize for StreamScanNode {
12409 #[allow(deprecated)]
12410 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12411 where
12412 S: serde::Serializer,
12413 {
12414 use serde::ser::SerializeStruct;
12415 let mut len = 0;
12416 if self.table_id != 0 {
12417 len += 1;
12418 }
12419 if !self.upstream_column_ids.is_empty() {
12420 len += 1;
12421 }
12422 if !self.output_indices.is_empty() {
12423 len += 1;
12424 }
12425 if self.stream_scan_type != 0 {
12426 len += 1;
12427 }
12428 if self.state_table.is_some() {
12429 len += 1;
12430 }
12431 if self.table_desc.is_some() {
12432 len += 1;
12433 }
12434 if self.rate_limit.is_some() {
12435 len += 1;
12436 }
12437 if self.snapshot_read_barrier_interval != 0 {
12438 len += 1;
12439 }
12440 if self.arrangement_table.is_some() {
12441 len += 1;
12442 }
12443 if self.snapshot_backfill_epoch.is_some() {
12444 len += 1;
12445 }
12446 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
12447 if self.table_id != 0 {
12448 struct_ser.serialize_field("tableId", &self.table_id)?;
12449 }
12450 if !self.upstream_column_ids.is_empty() {
12451 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12452 }
12453 if !self.output_indices.is_empty() {
12454 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12455 }
12456 if self.stream_scan_type != 0 {
12457 let v = StreamScanType::try_from(self.stream_scan_type)
12458 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
12459 struct_ser.serialize_field("streamScanType", &v)?;
12460 }
12461 if let Some(v) = self.state_table.as_ref() {
12462 struct_ser.serialize_field("stateTable", v)?;
12463 }
12464 if let Some(v) = self.table_desc.as_ref() {
12465 struct_ser.serialize_field("tableDesc", v)?;
12466 }
12467 if let Some(v) = self.rate_limit.as_ref() {
12468 struct_ser.serialize_field("rateLimit", v)?;
12469 }
12470 if self.snapshot_read_barrier_interval != 0 {
12471 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
12472 }
12473 if let Some(v) = self.arrangement_table.as_ref() {
12474 struct_ser.serialize_field("arrangementTable", v)?;
12475 }
12476 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
12477 #[allow(clippy::needless_borrow)]
12478 #[allow(clippy::needless_borrows_for_generic_args)]
12479 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
12480 }
12481 struct_ser.end()
12482 }
12483}
12484impl<'de> serde::Deserialize<'de> for StreamScanNode {
12485 #[allow(deprecated)]
12486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12487 where
12488 D: serde::Deserializer<'de>,
12489 {
12490 const FIELDS: &[&str] = &[
12491 "table_id",
12492 "tableId",
12493 "upstream_column_ids",
12494 "upstreamColumnIds",
12495 "output_indices",
12496 "outputIndices",
12497 "stream_scan_type",
12498 "streamScanType",
12499 "state_table",
12500 "stateTable",
12501 "table_desc",
12502 "tableDesc",
12503 "rate_limit",
12504 "rateLimit",
12505 "snapshot_read_barrier_interval",
12506 "snapshotReadBarrierInterval",
12507 "arrangement_table",
12508 "arrangementTable",
12509 "snapshot_backfill_epoch",
12510 "snapshotBackfillEpoch",
12511 ];
12512
12513 #[allow(clippy::enum_variant_names)]
12514 enum GeneratedField {
12515 TableId,
12516 UpstreamColumnIds,
12517 OutputIndices,
12518 StreamScanType,
12519 StateTable,
12520 TableDesc,
12521 RateLimit,
12522 SnapshotReadBarrierInterval,
12523 ArrangementTable,
12524 SnapshotBackfillEpoch,
12525 }
12526 impl<'de> serde::Deserialize<'de> for GeneratedField {
12527 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12528 where
12529 D: serde::Deserializer<'de>,
12530 {
12531 struct GeneratedVisitor;
12532
12533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12534 type Value = GeneratedField;
12535
12536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12537 write!(formatter, "expected one of: {:?}", &FIELDS)
12538 }
12539
12540 #[allow(unused_variables)]
12541 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12542 where
12543 E: serde::de::Error,
12544 {
12545 match value {
12546 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12547 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12548 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12549 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
12550 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12551 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
12552 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12553 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
12554 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
12555 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
12556 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12557 }
12558 }
12559 }
12560 deserializer.deserialize_identifier(GeneratedVisitor)
12561 }
12562 }
12563 struct GeneratedVisitor;
12564 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12565 type Value = StreamScanNode;
12566
12567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12568 formatter.write_str("struct stream_plan.StreamScanNode")
12569 }
12570
12571 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
12572 where
12573 V: serde::de::MapAccess<'de>,
12574 {
12575 let mut table_id__ = None;
12576 let mut upstream_column_ids__ = None;
12577 let mut output_indices__ = None;
12578 let mut stream_scan_type__ = None;
12579 let mut state_table__ = None;
12580 let mut table_desc__ = None;
12581 let mut rate_limit__ = None;
12582 let mut snapshot_read_barrier_interval__ = None;
12583 let mut arrangement_table__ = None;
12584 let mut snapshot_backfill_epoch__ = None;
12585 while let Some(k) = map_.next_key()? {
12586 match k {
12587 GeneratedField::TableId => {
12588 if table_id__.is_some() {
12589 return Err(serde::de::Error::duplicate_field("tableId"));
12590 }
12591 table_id__ =
12592 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12593 ;
12594 }
12595 GeneratedField::UpstreamColumnIds => {
12596 if upstream_column_ids__.is_some() {
12597 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12598 }
12599 upstream_column_ids__ =
12600 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12601 .into_iter().map(|x| x.0).collect())
12602 ;
12603 }
12604 GeneratedField::OutputIndices => {
12605 if output_indices__.is_some() {
12606 return Err(serde::de::Error::duplicate_field("outputIndices"));
12607 }
12608 output_indices__ =
12609 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12610 .into_iter().map(|x| x.0).collect())
12611 ;
12612 }
12613 GeneratedField::StreamScanType => {
12614 if stream_scan_type__.is_some() {
12615 return Err(serde::de::Error::duplicate_field("streamScanType"));
12616 }
12617 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
12618 }
12619 GeneratedField::StateTable => {
12620 if state_table__.is_some() {
12621 return Err(serde::de::Error::duplicate_field("stateTable"));
12622 }
12623 state_table__ = map_.next_value()?;
12624 }
12625 GeneratedField::TableDesc => {
12626 if table_desc__.is_some() {
12627 return Err(serde::de::Error::duplicate_field("tableDesc"));
12628 }
12629 table_desc__ = map_.next_value()?;
12630 }
12631 GeneratedField::RateLimit => {
12632 if rate_limit__.is_some() {
12633 return Err(serde::de::Error::duplicate_field("rateLimit"));
12634 }
12635 rate_limit__ =
12636 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12637 ;
12638 }
12639 GeneratedField::SnapshotReadBarrierInterval => {
12640 if snapshot_read_barrier_interval__.is_some() {
12641 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
12642 }
12643 snapshot_read_barrier_interval__ =
12644 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12645 ;
12646 }
12647 GeneratedField::ArrangementTable => {
12648 if arrangement_table__.is_some() {
12649 return Err(serde::de::Error::duplicate_field("arrangementTable"));
12650 }
12651 arrangement_table__ = map_.next_value()?;
12652 }
12653 GeneratedField::SnapshotBackfillEpoch => {
12654 if snapshot_backfill_epoch__.is_some() {
12655 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
12656 }
12657 snapshot_backfill_epoch__ =
12658 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12659 ;
12660 }
12661 }
12662 }
12663 Ok(StreamScanNode {
12664 table_id: table_id__.unwrap_or_default(),
12665 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12666 output_indices: output_indices__.unwrap_or_default(),
12667 stream_scan_type: stream_scan_type__.unwrap_or_default(),
12668 state_table: state_table__,
12669 table_desc: table_desc__,
12670 rate_limit: rate_limit__,
12671 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
12672 arrangement_table: arrangement_table__,
12673 snapshot_backfill_epoch: snapshot_backfill_epoch__,
12674 })
12675 }
12676 }
12677 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
12678 }
12679}
12680impl serde::Serialize for StreamScanType {
12681 #[allow(deprecated)]
12682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12683 where
12684 S: serde::Serializer,
12685 {
12686 let variant = match self {
12687 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
12688 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
12689 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
12690 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
12691 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12692 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12693 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12694 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12695 };
12696 serializer.serialize_str(variant)
12697 }
12698}
12699impl<'de> serde::Deserialize<'de> for StreamScanType {
12700 #[allow(deprecated)]
12701 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12702 where
12703 D: serde::Deserializer<'de>,
12704 {
12705 const FIELDS: &[&str] = &[
12706 "STREAM_SCAN_TYPE_UNSPECIFIED",
12707 "STREAM_SCAN_TYPE_CHAIN",
12708 "STREAM_SCAN_TYPE_REARRANGE",
12709 "STREAM_SCAN_TYPE_BACKFILL",
12710 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12711 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12712 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12713 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12714 ];
12715
12716 struct GeneratedVisitor;
12717
12718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12719 type Value = StreamScanType;
12720
12721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12722 write!(formatter, "expected one of: {:?}", &FIELDS)
12723 }
12724
12725 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12726 where
12727 E: serde::de::Error,
12728 {
12729 i32::try_from(v)
12730 .ok()
12731 .and_then(|x| x.try_into().ok())
12732 .ok_or_else(|| {
12733 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12734 })
12735 }
12736
12737 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12738 where
12739 E: serde::de::Error,
12740 {
12741 i32::try_from(v)
12742 .ok()
12743 .and_then(|x| x.try_into().ok())
12744 .ok_or_else(|| {
12745 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12746 })
12747 }
12748
12749 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12750 where
12751 E: serde::de::Error,
12752 {
12753 match value {
12754 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
12755 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
12756 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
12757 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
12758 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
12759 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
12760 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
12761 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
12762 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12763 }
12764 }
12765 }
12766 deserializer.deserialize_any(GeneratedVisitor)
12767 }
12768}
12769impl serde::Serialize for StreamSource {
12770 #[allow(deprecated)]
12771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12772 where
12773 S: serde::Serializer,
12774 {
12775 use serde::ser::SerializeStruct;
12776 let mut len = 0;
12777 if self.source_id != 0 {
12778 len += 1;
12779 }
12780 if self.state_table.is_some() {
12781 len += 1;
12782 }
12783 if self.row_id_index.is_some() {
12784 len += 1;
12785 }
12786 if !self.columns.is_empty() {
12787 len += 1;
12788 }
12789 if !self.with_properties.is_empty() {
12790 len += 1;
12791 }
12792 if self.info.is_some() {
12793 len += 1;
12794 }
12795 if !self.source_name.is_empty() {
12796 len += 1;
12797 }
12798 if self.rate_limit.is_some() {
12799 len += 1;
12800 }
12801 if !self.secret_refs.is_empty() {
12802 len += 1;
12803 }
12804 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
12805 if self.source_id != 0 {
12806 struct_ser.serialize_field("sourceId", &self.source_id)?;
12807 }
12808 if let Some(v) = self.state_table.as_ref() {
12809 struct_ser.serialize_field("stateTable", v)?;
12810 }
12811 if let Some(v) = self.row_id_index.as_ref() {
12812 struct_ser.serialize_field("rowIdIndex", v)?;
12813 }
12814 if !self.columns.is_empty() {
12815 struct_ser.serialize_field("columns", &self.columns)?;
12816 }
12817 if !self.with_properties.is_empty() {
12818 struct_ser.serialize_field("withProperties", &self.with_properties)?;
12819 }
12820 if let Some(v) = self.info.as_ref() {
12821 struct_ser.serialize_field("info", v)?;
12822 }
12823 if !self.source_name.is_empty() {
12824 struct_ser.serialize_field("sourceName", &self.source_name)?;
12825 }
12826 if let Some(v) = self.rate_limit.as_ref() {
12827 struct_ser.serialize_field("rateLimit", v)?;
12828 }
12829 if !self.secret_refs.is_empty() {
12830 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
12831 }
12832 struct_ser.end()
12833 }
12834}
12835impl<'de> serde::Deserialize<'de> for StreamSource {
12836 #[allow(deprecated)]
12837 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12838 where
12839 D: serde::Deserializer<'de>,
12840 {
12841 const FIELDS: &[&str] = &[
12842 "source_id",
12843 "sourceId",
12844 "state_table",
12845 "stateTable",
12846 "row_id_index",
12847 "rowIdIndex",
12848 "columns",
12849 "with_properties",
12850 "withProperties",
12851 "info",
12852 "source_name",
12853 "sourceName",
12854 "rate_limit",
12855 "rateLimit",
12856 "secret_refs",
12857 "secretRefs",
12858 ];
12859
12860 #[allow(clippy::enum_variant_names)]
12861 enum GeneratedField {
12862 SourceId,
12863 StateTable,
12864 RowIdIndex,
12865 Columns,
12866 WithProperties,
12867 Info,
12868 SourceName,
12869 RateLimit,
12870 SecretRefs,
12871 }
12872 impl<'de> serde::Deserialize<'de> for GeneratedField {
12873 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12874 where
12875 D: serde::Deserializer<'de>,
12876 {
12877 struct GeneratedVisitor;
12878
12879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12880 type Value = GeneratedField;
12881
12882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12883 write!(formatter, "expected one of: {:?}", &FIELDS)
12884 }
12885
12886 #[allow(unused_variables)]
12887 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12888 where
12889 E: serde::de::Error,
12890 {
12891 match value {
12892 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12893 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12894 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12895 "columns" => Ok(GeneratedField::Columns),
12896 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
12897 "info" => Ok(GeneratedField::Info),
12898 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
12899 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12900 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
12901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12902 }
12903 }
12904 }
12905 deserializer.deserialize_identifier(GeneratedVisitor)
12906 }
12907 }
12908 struct GeneratedVisitor;
12909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12910 type Value = StreamSource;
12911
12912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12913 formatter.write_str("struct stream_plan.StreamSource")
12914 }
12915
12916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
12917 where
12918 V: serde::de::MapAccess<'de>,
12919 {
12920 let mut source_id__ = None;
12921 let mut state_table__ = None;
12922 let mut row_id_index__ = None;
12923 let mut columns__ = None;
12924 let mut with_properties__ = None;
12925 let mut info__ = None;
12926 let mut source_name__ = None;
12927 let mut rate_limit__ = None;
12928 let mut secret_refs__ = None;
12929 while let Some(k) = map_.next_key()? {
12930 match k {
12931 GeneratedField::SourceId => {
12932 if source_id__.is_some() {
12933 return Err(serde::de::Error::duplicate_field("sourceId"));
12934 }
12935 source_id__ =
12936 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12937 ;
12938 }
12939 GeneratedField::StateTable => {
12940 if state_table__.is_some() {
12941 return Err(serde::de::Error::duplicate_field("stateTable"));
12942 }
12943 state_table__ = map_.next_value()?;
12944 }
12945 GeneratedField::RowIdIndex => {
12946 if row_id_index__.is_some() {
12947 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12948 }
12949 row_id_index__ =
12950 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12951 ;
12952 }
12953 GeneratedField::Columns => {
12954 if columns__.is_some() {
12955 return Err(serde::de::Error::duplicate_field("columns"));
12956 }
12957 columns__ = Some(map_.next_value()?);
12958 }
12959 GeneratedField::WithProperties => {
12960 if with_properties__.is_some() {
12961 return Err(serde::de::Error::duplicate_field("withProperties"));
12962 }
12963 with_properties__ = Some(
12964 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12965 );
12966 }
12967 GeneratedField::Info => {
12968 if info__.is_some() {
12969 return Err(serde::de::Error::duplicate_field("info"));
12970 }
12971 info__ = map_.next_value()?;
12972 }
12973 GeneratedField::SourceName => {
12974 if source_name__.is_some() {
12975 return Err(serde::de::Error::duplicate_field("sourceName"));
12976 }
12977 source_name__ = Some(map_.next_value()?);
12978 }
12979 GeneratedField::RateLimit => {
12980 if rate_limit__.is_some() {
12981 return Err(serde::de::Error::duplicate_field("rateLimit"));
12982 }
12983 rate_limit__ =
12984 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12985 ;
12986 }
12987 GeneratedField::SecretRefs => {
12988 if secret_refs__.is_some() {
12989 return Err(serde::de::Error::duplicate_field("secretRefs"));
12990 }
12991 secret_refs__ = Some(
12992 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12993 );
12994 }
12995 }
12996 }
12997 Ok(StreamSource {
12998 source_id: source_id__.unwrap_or_default(),
12999 state_table: state_table__,
13000 row_id_index: row_id_index__,
13001 columns: columns__.unwrap_or_default(),
13002 with_properties: with_properties__.unwrap_or_default(),
13003 info: info__,
13004 source_name: source_name__.unwrap_or_default(),
13005 rate_limit: rate_limit__,
13006 secret_refs: secret_refs__.unwrap_or_default(),
13007 })
13008 }
13009 }
13010 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13011 }
13012}
13013impl serde::Serialize for SubscriptionUpstreamInfo {
13014 #[allow(deprecated)]
13015 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13016 where
13017 S: serde::Serializer,
13018 {
13019 use serde::ser::SerializeStruct;
13020 let mut len = 0;
13021 if self.subscriber_id != 0 {
13022 len += 1;
13023 }
13024 if self.upstream_mv_table_id != 0 {
13025 len += 1;
13026 }
13027 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13028 if self.subscriber_id != 0 {
13029 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13030 }
13031 if self.upstream_mv_table_id != 0 {
13032 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13033 }
13034 struct_ser.end()
13035 }
13036}
13037impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13038 #[allow(deprecated)]
13039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13040 where
13041 D: serde::Deserializer<'de>,
13042 {
13043 const FIELDS: &[&str] = &[
13044 "subscriber_id",
13045 "subscriberId",
13046 "upstream_mv_table_id",
13047 "upstreamMvTableId",
13048 ];
13049
13050 #[allow(clippy::enum_variant_names)]
13051 enum GeneratedField {
13052 SubscriberId,
13053 UpstreamMvTableId,
13054 }
13055 impl<'de> serde::Deserialize<'de> for GeneratedField {
13056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13057 where
13058 D: serde::Deserializer<'de>,
13059 {
13060 struct GeneratedVisitor;
13061
13062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13063 type Value = GeneratedField;
13064
13065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13066 write!(formatter, "expected one of: {:?}", &FIELDS)
13067 }
13068
13069 #[allow(unused_variables)]
13070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13071 where
13072 E: serde::de::Error,
13073 {
13074 match value {
13075 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
13076 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
13077 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13078 }
13079 }
13080 }
13081 deserializer.deserialize_identifier(GeneratedVisitor)
13082 }
13083 }
13084 struct GeneratedVisitor;
13085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13086 type Value = SubscriptionUpstreamInfo;
13087
13088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13089 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
13090 }
13091
13092 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
13093 where
13094 V: serde::de::MapAccess<'de>,
13095 {
13096 let mut subscriber_id__ = None;
13097 let mut upstream_mv_table_id__ = None;
13098 while let Some(k) = map_.next_key()? {
13099 match k {
13100 GeneratedField::SubscriberId => {
13101 if subscriber_id__.is_some() {
13102 return Err(serde::de::Error::duplicate_field("subscriberId"));
13103 }
13104 subscriber_id__ =
13105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13106 ;
13107 }
13108 GeneratedField::UpstreamMvTableId => {
13109 if upstream_mv_table_id__.is_some() {
13110 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13111 }
13112 upstream_mv_table_id__ =
13113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13114 ;
13115 }
13116 }
13117 }
13118 Ok(SubscriptionUpstreamInfo {
13119 subscriber_id: subscriber_id__.unwrap_or_default(),
13120 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13121 })
13122 }
13123 }
13124 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13125 }
13126}
13127impl serde::Serialize for SyncLogStoreNode {
13128 #[allow(deprecated)]
13129 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13130 where
13131 S: serde::Serializer,
13132 {
13133 use serde::ser::SerializeStruct;
13134 let mut len = 0;
13135 if self.log_store_table.is_some() {
13136 len += 1;
13137 }
13138 if self.pause_duration_ms != 0 {
13139 len += 1;
13140 }
13141 if self.buffer_size != 0 {
13142 len += 1;
13143 }
13144 if self.aligned {
13145 len += 1;
13146 }
13147 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13148 if let Some(v) = self.log_store_table.as_ref() {
13149 struct_ser.serialize_field("logStoreTable", v)?;
13150 }
13151 if self.pause_duration_ms != 0 {
13152 struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13153 }
13154 if self.buffer_size != 0 {
13155 struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13156 }
13157 if self.aligned {
13158 struct_ser.serialize_field("aligned", &self.aligned)?;
13159 }
13160 struct_ser.end()
13161 }
13162}
13163impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13164 #[allow(deprecated)]
13165 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13166 where
13167 D: serde::Deserializer<'de>,
13168 {
13169 const FIELDS: &[&str] = &[
13170 "log_store_table",
13171 "logStoreTable",
13172 "pause_duration_ms",
13173 "pauseDurationMs",
13174 "buffer_size",
13175 "bufferSize",
13176 "aligned",
13177 ];
13178
13179 #[allow(clippy::enum_variant_names)]
13180 enum GeneratedField {
13181 LogStoreTable,
13182 PauseDurationMs,
13183 BufferSize,
13184 Aligned,
13185 }
13186 impl<'de> serde::Deserialize<'de> for GeneratedField {
13187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13188 where
13189 D: serde::Deserializer<'de>,
13190 {
13191 struct GeneratedVisitor;
13192
13193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13194 type Value = GeneratedField;
13195
13196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13197 write!(formatter, "expected one of: {:?}", &FIELDS)
13198 }
13199
13200 #[allow(unused_variables)]
13201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13202 where
13203 E: serde::de::Error,
13204 {
13205 match value {
13206 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
13207 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
13208 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
13209 "aligned" => Ok(GeneratedField::Aligned),
13210 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13211 }
13212 }
13213 }
13214 deserializer.deserialize_identifier(GeneratedVisitor)
13215 }
13216 }
13217 struct GeneratedVisitor;
13218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13219 type Value = SyncLogStoreNode;
13220
13221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13222 formatter.write_str("struct stream_plan.SyncLogStoreNode")
13223 }
13224
13225 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
13226 where
13227 V: serde::de::MapAccess<'de>,
13228 {
13229 let mut log_store_table__ = None;
13230 let mut pause_duration_ms__ = None;
13231 let mut buffer_size__ = None;
13232 let mut aligned__ = None;
13233 while let Some(k) = map_.next_key()? {
13234 match k {
13235 GeneratedField::LogStoreTable => {
13236 if log_store_table__.is_some() {
13237 return Err(serde::de::Error::duplicate_field("logStoreTable"));
13238 }
13239 log_store_table__ = map_.next_value()?;
13240 }
13241 GeneratedField::PauseDurationMs => {
13242 if pause_duration_ms__.is_some() {
13243 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
13244 }
13245 pause_duration_ms__ =
13246 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13247 ;
13248 }
13249 GeneratedField::BufferSize => {
13250 if buffer_size__.is_some() {
13251 return Err(serde::de::Error::duplicate_field("bufferSize"));
13252 }
13253 buffer_size__ =
13254 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13255 ;
13256 }
13257 GeneratedField::Aligned => {
13258 if aligned__.is_some() {
13259 return Err(serde::de::Error::duplicate_field("aligned"));
13260 }
13261 aligned__ = Some(map_.next_value()?);
13262 }
13263 }
13264 }
13265 Ok(SyncLogStoreNode {
13266 log_store_table: log_store_table__,
13267 pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
13268 buffer_size: buffer_size__.unwrap_or_default(),
13269 aligned: aligned__.unwrap_or_default(),
13270 })
13271 }
13272 }
13273 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
13274 }
13275}
13276impl serde::Serialize for TemporalJoinNode {
13277 #[allow(deprecated)]
13278 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13279 where
13280 S: serde::Serializer,
13281 {
13282 use serde::ser::SerializeStruct;
13283 let mut len = 0;
13284 if self.join_type != 0 {
13285 len += 1;
13286 }
13287 if !self.left_key.is_empty() {
13288 len += 1;
13289 }
13290 if !self.right_key.is_empty() {
13291 len += 1;
13292 }
13293 if !self.null_safe.is_empty() {
13294 len += 1;
13295 }
13296 if self.condition.is_some() {
13297 len += 1;
13298 }
13299 if !self.output_indices.is_empty() {
13300 len += 1;
13301 }
13302 if self.table_desc.is_some() {
13303 len += 1;
13304 }
13305 if !self.table_output_indices.is_empty() {
13306 len += 1;
13307 }
13308 if self.memo_table.is_some() {
13309 len += 1;
13310 }
13311 if self.is_nested_loop {
13312 len += 1;
13313 }
13314 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
13315 if self.join_type != 0 {
13316 let v = super::plan_common::JoinType::try_from(self.join_type)
13317 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
13318 struct_ser.serialize_field("joinType", &v)?;
13319 }
13320 if !self.left_key.is_empty() {
13321 struct_ser.serialize_field("leftKey", &self.left_key)?;
13322 }
13323 if !self.right_key.is_empty() {
13324 struct_ser.serialize_field("rightKey", &self.right_key)?;
13325 }
13326 if !self.null_safe.is_empty() {
13327 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
13328 }
13329 if let Some(v) = self.condition.as_ref() {
13330 struct_ser.serialize_field("condition", v)?;
13331 }
13332 if !self.output_indices.is_empty() {
13333 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13334 }
13335 if let Some(v) = self.table_desc.as_ref() {
13336 struct_ser.serialize_field("tableDesc", v)?;
13337 }
13338 if !self.table_output_indices.is_empty() {
13339 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
13340 }
13341 if let Some(v) = self.memo_table.as_ref() {
13342 struct_ser.serialize_field("memoTable", v)?;
13343 }
13344 if self.is_nested_loop {
13345 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
13346 }
13347 struct_ser.end()
13348 }
13349}
13350impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
13351 #[allow(deprecated)]
13352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13353 where
13354 D: serde::Deserializer<'de>,
13355 {
13356 const FIELDS: &[&str] = &[
13357 "join_type",
13358 "joinType",
13359 "left_key",
13360 "leftKey",
13361 "right_key",
13362 "rightKey",
13363 "null_safe",
13364 "nullSafe",
13365 "condition",
13366 "output_indices",
13367 "outputIndices",
13368 "table_desc",
13369 "tableDesc",
13370 "table_output_indices",
13371 "tableOutputIndices",
13372 "memo_table",
13373 "memoTable",
13374 "is_nested_loop",
13375 "isNestedLoop",
13376 ];
13377
13378 #[allow(clippy::enum_variant_names)]
13379 enum GeneratedField {
13380 JoinType,
13381 LeftKey,
13382 RightKey,
13383 NullSafe,
13384 Condition,
13385 OutputIndices,
13386 TableDesc,
13387 TableOutputIndices,
13388 MemoTable,
13389 IsNestedLoop,
13390 }
13391 impl<'de> serde::Deserialize<'de> for GeneratedField {
13392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13393 where
13394 D: serde::Deserializer<'de>,
13395 {
13396 struct GeneratedVisitor;
13397
13398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13399 type Value = GeneratedField;
13400
13401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13402 write!(formatter, "expected one of: {:?}", &FIELDS)
13403 }
13404
13405 #[allow(unused_variables)]
13406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13407 where
13408 E: serde::de::Error,
13409 {
13410 match value {
13411 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
13412 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
13413 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
13414 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
13415 "condition" => Ok(GeneratedField::Condition),
13416 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13417 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13418 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
13419 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
13420 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
13421 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13422 }
13423 }
13424 }
13425 deserializer.deserialize_identifier(GeneratedVisitor)
13426 }
13427 }
13428 struct GeneratedVisitor;
13429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13430 type Value = TemporalJoinNode;
13431
13432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13433 formatter.write_str("struct stream_plan.TemporalJoinNode")
13434 }
13435
13436 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
13437 where
13438 V: serde::de::MapAccess<'de>,
13439 {
13440 let mut join_type__ = None;
13441 let mut left_key__ = None;
13442 let mut right_key__ = None;
13443 let mut null_safe__ = None;
13444 let mut condition__ = None;
13445 let mut output_indices__ = None;
13446 let mut table_desc__ = None;
13447 let mut table_output_indices__ = None;
13448 let mut memo_table__ = None;
13449 let mut is_nested_loop__ = None;
13450 while let Some(k) = map_.next_key()? {
13451 match k {
13452 GeneratedField::JoinType => {
13453 if join_type__.is_some() {
13454 return Err(serde::de::Error::duplicate_field("joinType"));
13455 }
13456 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
13457 }
13458 GeneratedField::LeftKey => {
13459 if left_key__.is_some() {
13460 return Err(serde::de::Error::duplicate_field("leftKey"));
13461 }
13462 left_key__ =
13463 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13464 .into_iter().map(|x| x.0).collect())
13465 ;
13466 }
13467 GeneratedField::RightKey => {
13468 if right_key__.is_some() {
13469 return Err(serde::de::Error::duplicate_field("rightKey"));
13470 }
13471 right_key__ =
13472 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13473 .into_iter().map(|x| x.0).collect())
13474 ;
13475 }
13476 GeneratedField::NullSafe => {
13477 if null_safe__.is_some() {
13478 return Err(serde::de::Error::duplicate_field("nullSafe"));
13479 }
13480 null_safe__ = Some(map_.next_value()?);
13481 }
13482 GeneratedField::Condition => {
13483 if condition__.is_some() {
13484 return Err(serde::de::Error::duplicate_field("condition"));
13485 }
13486 condition__ = map_.next_value()?;
13487 }
13488 GeneratedField::OutputIndices => {
13489 if output_indices__.is_some() {
13490 return Err(serde::de::Error::duplicate_field("outputIndices"));
13491 }
13492 output_indices__ =
13493 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13494 .into_iter().map(|x| x.0).collect())
13495 ;
13496 }
13497 GeneratedField::TableDesc => {
13498 if table_desc__.is_some() {
13499 return Err(serde::de::Error::duplicate_field("tableDesc"));
13500 }
13501 table_desc__ = map_.next_value()?;
13502 }
13503 GeneratedField::TableOutputIndices => {
13504 if table_output_indices__.is_some() {
13505 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
13506 }
13507 table_output_indices__ =
13508 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13509 .into_iter().map(|x| x.0).collect())
13510 ;
13511 }
13512 GeneratedField::MemoTable => {
13513 if memo_table__.is_some() {
13514 return Err(serde::de::Error::duplicate_field("memoTable"));
13515 }
13516 memo_table__ = map_.next_value()?;
13517 }
13518 GeneratedField::IsNestedLoop => {
13519 if is_nested_loop__.is_some() {
13520 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
13521 }
13522 is_nested_loop__ = Some(map_.next_value()?);
13523 }
13524 }
13525 }
13526 Ok(TemporalJoinNode {
13527 join_type: join_type__.unwrap_or_default(),
13528 left_key: left_key__.unwrap_or_default(),
13529 right_key: right_key__.unwrap_or_default(),
13530 null_safe: null_safe__.unwrap_or_default(),
13531 condition: condition__,
13532 output_indices: output_indices__.unwrap_or_default(),
13533 table_desc: table_desc__,
13534 table_output_indices: table_output_indices__.unwrap_or_default(),
13535 memo_table: memo_table__,
13536 is_nested_loop: is_nested_loop__.unwrap_or_default(),
13537 })
13538 }
13539 }
13540 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
13541 }
13542}
13543impl serde::Serialize for ThrottleMutation {
13544 #[allow(deprecated)]
13545 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13546 where
13547 S: serde::Serializer,
13548 {
13549 use serde::ser::SerializeStruct;
13550 let mut len = 0;
13551 if !self.actor_throttle.is_empty() {
13552 len += 1;
13553 }
13554 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
13555 if !self.actor_throttle.is_empty() {
13556 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
13557 }
13558 struct_ser.end()
13559 }
13560}
13561impl<'de> serde::Deserialize<'de> for ThrottleMutation {
13562 #[allow(deprecated)]
13563 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13564 where
13565 D: serde::Deserializer<'de>,
13566 {
13567 const FIELDS: &[&str] = &[
13568 "actor_throttle",
13569 "actorThrottle",
13570 ];
13571
13572 #[allow(clippy::enum_variant_names)]
13573 enum GeneratedField {
13574 ActorThrottle,
13575 }
13576 impl<'de> serde::Deserialize<'de> for GeneratedField {
13577 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13578 where
13579 D: serde::Deserializer<'de>,
13580 {
13581 struct GeneratedVisitor;
13582
13583 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13584 type Value = GeneratedField;
13585
13586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13587 write!(formatter, "expected one of: {:?}", &FIELDS)
13588 }
13589
13590 #[allow(unused_variables)]
13591 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13592 where
13593 E: serde::de::Error,
13594 {
13595 match value {
13596 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
13597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13598 }
13599 }
13600 }
13601 deserializer.deserialize_identifier(GeneratedVisitor)
13602 }
13603 }
13604 struct GeneratedVisitor;
13605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13606 type Value = ThrottleMutation;
13607
13608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13609 formatter.write_str("struct stream_plan.ThrottleMutation")
13610 }
13611
13612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
13613 where
13614 V: serde::de::MapAccess<'de>,
13615 {
13616 let mut actor_throttle__ = None;
13617 while let Some(k) = map_.next_key()? {
13618 match k {
13619 GeneratedField::ActorThrottle => {
13620 if actor_throttle__.is_some() {
13621 return Err(serde::de::Error::duplicate_field("actorThrottle"));
13622 }
13623 actor_throttle__ = Some(
13624 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13625 .into_iter().map(|(k,v)| (k.0, v)).collect()
13626 );
13627 }
13628 }
13629 }
13630 Ok(ThrottleMutation {
13631 actor_throttle: actor_throttle__.unwrap_or_default(),
13632 })
13633 }
13634 }
13635 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
13636 }
13637}
13638impl serde::Serialize for throttle_mutation::RateLimit {
13639 #[allow(deprecated)]
13640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13641 where
13642 S: serde::Serializer,
13643 {
13644 use serde::ser::SerializeStruct;
13645 let mut len = 0;
13646 if self.rate_limit.is_some() {
13647 len += 1;
13648 }
13649 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
13650 if let Some(v) = self.rate_limit.as_ref() {
13651 struct_ser.serialize_field("rateLimit", v)?;
13652 }
13653 struct_ser.end()
13654 }
13655}
13656impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
13657 #[allow(deprecated)]
13658 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13659 where
13660 D: serde::Deserializer<'de>,
13661 {
13662 const FIELDS: &[&str] = &[
13663 "rate_limit",
13664 "rateLimit",
13665 ];
13666
13667 #[allow(clippy::enum_variant_names)]
13668 enum GeneratedField {
13669 RateLimit,
13670 }
13671 impl<'de> serde::Deserialize<'de> for GeneratedField {
13672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13673 where
13674 D: serde::Deserializer<'de>,
13675 {
13676 struct GeneratedVisitor;
13677
13678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13679 type Value = GeneratedField;
13680
13681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13682 write!(formatter, "expected one of: {:?}", &FIELDS)
13683 }
13684
13685 #[allow(unused_variables)]
13686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13687 where
13688 E: serde::de::Error,
13689 {
13690 match value {
13691 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13692 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13693 }
13694 }
13695 }
13696 deserializer.deserialize_identifier(GeneratedVisitor)
13697 }
13698 }
13699 struct GeneratedVisitor;
13700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13701 type Value = throttle_mutation::RateLimit;
13702
13703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13704 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
13705 }
13706
13707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
13708 where
13709 V: serde::de::MapAccess<'de>,
13710 {
13711 let mut rate_limit__ = None;
13712 while let Some(k) = map_.next_key()? {
13713 match k {
13714 GeneratedField::RateLimit => {
13715 if rate_limit__.is_some() {
13716 return Err(serde::de::Error::duplicate_field("rateLimit"));
13717 }
13718 rate_limit__ =
13719 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13720 ;
13721 }
13722 }
13723 }
13724 Ok(throttle_mutation::RateLimit {
13725 rate_limit: rate_limit__,
13726 })
13727 }
13728 }
13729 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
13730 }
13731}
13732impl serde::Serialize for TopNNode {
13733 #[allow(deprecated)]
13734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13735 where
13736 S: serde::Serializer,
13737 {
13738 use serde::ser::SerializeStruct;
13739 let mut len = 0;
13740 if self.limit != 0 {
13741 len += 1;
13742 }
13743 if self.offset != 0 {
13744 len += 1;
13745 }
13746 if self.table.is_some() {
13747 len += 1;
13748 }
13749 if !self.order_by.is_empty() {
13750 len += 1;
13751 }
13752 if self.with_ties {
13753 len += 1;
13754 }
13755 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
13756 if self.limit != 0 {
13757 #[allow(clippy::needless_borrow)]
13758 #[allow(clippy::needless_borrows_for_generic_args)]
13759 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
13760 }
13761 if self.offset != 0 {
13762 #[allow(clippy::needless_borrow)]
13763 #[allow(clippy::needless_borrows_for_generic_args)]
13764 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
13765 }
13766 if let Some(v) = self.table.as_ref() {
13767 struct_ser.serialize_field("table", v)?;
13768 }
13769 if !self.order_by.is_empty() {
13770 struct_ser.serialize_field("orderBy", &self.order_by)?;
13771 }
13772 if self.with_ties {
13773 struct_ser.serialize_field("withTies", &self.with_ties)?;
13774 }
13775 struct_ser.end()
13776 }
13777}
13778impl<'de> serde::Deserialize<'de> for TopNNode {
13779 #[allow(deprecated)]
13780 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13781 where
13782 D: serde::Deserializer<'de>,
13783 {
13784 const FIELDS: &[&str] = &[
13785 "limit",
13786 "offset",
13787 "table",
13788 "order_by",
13789 "orderBy",
13790 "with_ties",
13791 "withTies",
13792 ];
13793
13794 #[allow(clippy::enum_variant_names)]
13795 enum GeneratedField {
13796 Limit,
13797 Offset,
13798 Table,
13799 OrderBy,
13800 WithTies,
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 match value {
13822 "limit" => Ok(GeneratedField::Limit),
13823 "offset" => Ok(GeneratedField::Offset),
13824 "table" => Ok(GeneratedField::Table),
13825 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
13826 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
13827 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13828 }
13829 }
13830 }
13831 deserializer.deserialize_identifier(GeneratedVisitor)
13832 }
13833 }
13834 struct GeneratedVisitor;
13835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13836 type Value = TopNNode;
13837
13838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13839 formatter.write_str("struct stream_plan.TopNNode")
13840 }
13841
13842 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
13843 where
13844 V: serde::de::MapAccess<'de>,
13845 {
13846 let mut limit__ = None;
13847 let mut offset__ = None;
13848 let mut table__ = None;
13849 let mut order_by__ = None;
13850 let mut with_ties__ = None;
13851 while let Some(k) = map_.next_key()? {
13852 match k {
13853 GeneratedField::Limit => {
13854 if limit__.is_some() {
13855 return Err(serde::de::Error::duplicate_field("limit"));
13856 }
13857 limit__ =
13858 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13859 ;
13860 }
13861 GeneratedField::Offset => {
13862 if offset__.is_some() {
13863 return Err(serde::de::Error::duplicate_field("offset"));
13864 }
13865 offset__ =
13866 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13867 ;
13868 }
13869 GeneratedField::Table => {
13870 if table__.is_some() {
13871 return Err(serde::de::Error::duplicate_field("table"));
13872 }
13873 table__ = map_.next_value()?;
13874 }
13875 GeneratedField::OrderBy => {
13876 if order_by__.is_some() {
13877 return Err(serde::de::Error::duplicate_field("orderBy"));
13878 }
13879 order_by__ = Some(map_.next_value()?);
13880 }
13881 GeneratedField::WithTies => {
13882 if with_ties__.is_some() {
13883 return Err(serde::de::Error::duplicate_field("withTies"));
13884 }
13885 with_ties__ = Some(map_.next_value()?);
13886 }
13887 }
13888 }
13889 Ok(TopNNode {
13890 limit: limit__.unwrap_or_default(),
13891 offset: offset__.unwrap_or_default(),
13892 table: table__,
13893 order_by: order_by__.unwrap_or_default(),
13894 with_ties: with_ties__.unwrap_or_default(),
13895 })
13896 }
13897 }
13898 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
13899 }
13900}
13901impl serde::Serialize for UnionNode {
13902 #[allow(deprecated)]
13903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13904 where
13905 S: serde::Serializer,
13906 {
13907 use serde::ser::SerializeStruct;
13908 let len = 0;
13909 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
13910 struct_ser.end()
13911 }
13912}
13913impl<'de> serde::Deserialize<'de> for UnionNode {
13914 #[allow(deprecated)]
13915 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13916 where
13917 D: serde::Deserializer<'de>,
13918 {
13919 const FIELDS: &[&str] = &[
13920 ];
13921
13922 #[allow(clippy::enum_variant_names)]
13923 enum GeneratedField {
13924 }
13925 impl<'de> serde::Deserialize<'de> for GeneratedField {
13926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13927 where
13928 D: serde::Deserializer<'de>,
13929 {
13930 struct GeneratedVisitor;
13931
13932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13933 type Value = GeneratedField;
13934
13935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13936 write!(formatter, "expected one of: {:?}", &FIELDS)
13937 }
13938
13939 #[allow(unused_variables)]
13940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13941 where
13942 E: serde::de::Error,
13943 {
13944 Err(serde::de::Error::unknown_field(value, FIELDS))
13945 }
13946 }
13947 deserializer.deserialize_identifier(GeneratedVisitor)
13948 }
13949 }
13950 struct GeneratedVisitor;
13951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13952 type Value = UnionNode;
13953
13954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13955 formatter.write_str("struct stream_plan.UnionNode")
13956 }
13957
13958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
13959 where
13960 V: serde::de::MapAccess<'de>,
13961 {
13962 while map_.next_key::<GeneratedField>()?.is_some() {
13963 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13964 }
13965 Ok(UnionNode {
13966 })
13967 }
13968 }
13969 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
13970 }
13971}
13972impl serde::Serialize for UpdateMutation {
13973 #[allow(deprecated)]
13974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13975 where
13976 S: serde::Serializer,
13977 {
13978 use serde::ser::SerializeStruct;
13979 let mut len = 0;
13980 if !self.dispatcher_update.is_empty() {
13981 len += 1;
13982 }
13983 if !self.merge_update.is_empty() {
13984 len += 1;
13985 }
13986 if !self.actor_vnode_bitmap_update.is_empty() {
13987 len += 1;
13988 }
13989 if !self.dropped_actors.is_empty() {
13990 len += 1;
13991 }
13992 if !self.actor_splits.is_empty() {
13993 len += 1;
13994 }
13995 if !self.actor_new_dispatchers.is_empty() {
13996 len += 1;
13997 }
13998 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
13999 if !self.dispatcher_update.is_empty() {
14000 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14001 }
14002 if !self.merge_update.is_empty() {
14003 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14004 }
14005 if !self.actor_vnode_bitmap_update.is_empty() {
14006 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14007 }
14008 if !self.dropped_actors.is_empty() {
14009 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14010 }
14011 if !self.actor_splits.is_empty() {
14012 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14013 }
14014 if !self.actor_new_dispatchers.is_empty() {
14015 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14016 }
14017 struct_ser.end()
14018 }
14019}
14020impl<'de> serde::Deserialize<'de> for UpdateMutation {
14021 #[allow(deprecated)]
14022 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14023 where
14024 D: serde::Deserializer<'de>,
14025 {
14026 const FIELDS: &[&str] = &[
14027 "dispatcher_update",
14028 "dispatcherUpdate",
14029 "merge_update",
14030 "mergeUpdate",
14031 "actor_vnode_bitmap_update",
14032 "actorVnodeBitmapUpdate",
14033 "dropped_actors",
14034 "droppedActors",
14035 "actor_splits",
14036 "actorSplits",
14037 "actor_new_dispatchers",
14038 "actorNewDispatchers",
14039 ];
14040
14041 #[allow(clippy::enum_variant_names)]
14042 enum GeneratedField {
14043 DispatcherUpdate,
14044 MergeUpdate,
14045 ActorVnodeBitmapUpdate,
14046 DroppedActors,
14047 ActorSplits,
14048 ActorNewDispatchers,
14049 }
14050 impl<'de> serde::Deserialize<'de> for GeneratedField {
14051 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14052 where
14053 D: serde::Deserializer<'de>,
14054 {
14055 struct GeneratedVisitor;
14056
14057 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14058 type Value = GeneratedField;
14059
14060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14061 write!(formatter, "expected one of: {:?}", &FIELDS)
14062 }
14063
14064 #[allow(unused_variables)]
14065 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14066 where
14067 E: serde::de::Error,
14068 {
14069 match value {
14070 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
14071 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
14072 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
14073 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
14074 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14075 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
14076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14077 }
14078 }
14079 }
14080 deserializer.deserialize_identifier(GeneratedVisitor)
14081 }
14082 }
14083 struct GeneratedVisitor;
14084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14085 type Value = UpdateMutation;
14086
14087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14088 formatter.write_str("struct stream_plan.UpdateMutation")
14089 }
14090
14091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
14092 where
14093 V: serde::de::MapAccess<'de>,
14094 {
14095 let mut dispatcher_update__ = None;
14096 let mut merge_update__ = None;
14097 let mut actor_vnode_bitmap_update__ = None;
14098 let mut dropped_actors__ = None;
14099 let mut actor_splits__ = None;
14100 let mut actor_new_dispatchers__ = None;
14101 while let Some(k) = map_.next_key()? {
14102 match k {
14103 GeneratedField::DispatcherUpdate => {
14104 if dispatcher_update__.is_some() {
14105 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
14106 }
14107 dispatcher_update__ = Some(map_.next_value()?);
14108 }
14109 GeneratedField::MergeUpdate => {
14110 if merge_update__.is_some() {
14111 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
14112 }
14113 merge_update__ = Some(map_.next_value()?);
14114 }
14115 GeneratedField::ActorVnodeBitmapUpdate => {
14116 if actor_vnode_bitmap_update__.is_some() {
14117 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
14118 }
14119 actor_vnode_bitmap_update__ = Some(
14120 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14121 .into_iter().map(|(k,v)| (k.0, v)).collect()
14122 );
14123 }
14124 GeneratedField::DroppedActors => {
14125 if dropped_actors__.is_some() {
14126 return Err(serde::de::Error::duplicate_field("droppedActors"));
14127 }
14128 dropped_actors__ =
14129 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14130 .into_iter().map(|x| x.0).collect())
14131 ;
14132 }
14133 GeneratedField::ActorSplits => {
14134 if actor_splits__.is_some() {
14135 return Err(serde::de::Error::duplicate_field("actorSplits"));
14136 }
14137 actor_splits__ = Some(
14138 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14139 .into_iter().map(|(k,v)| (k.0, v)).collect()
14140 );
14141 }
14142 GeneratedField::ActorNewDispatchers => {
14143 if actor_new_dispatchers__.is_some() {
14144 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14145 }
14146 actor_new_dispatchers__ = Some(
14147 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14148 .into_iter().map(|(k,v)| (k.0, v)).collect()
14149 );
14150 }
14151 }
14152 }
14153 Ok(UpdateMutation {
14154 dispatcher_update: dispatcher_update__.unwrap_or_default(),
14155 merge_update: merge_update__.unwrap_or_default(),
14156 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
14157 dropped_actors: dropped_actors__.unwrap_or_default(),
14158 actor_splits: actor_splits__.unwrap_or_default(),
14159 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
14160 })
14161 }
14162 }
14163 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
14164 }
14165}
14166impl serde::Serialize for update_mutation::DispatcherUpdate {
14167 #[allow(deprecated)]
14168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14169 where
14170 S: serde::Serializer,
14171 {
14172 use serde::ser::SerializeStruct;
14173 let mut len = 0;
14174 if self.actor_id != 0 {
14175 len += 1;
14176 }
14177 if self.dispatcher_id != 0 {
14178 len += 1;
14179 }
14180 if self.hash_mapping.is_some() {
14181 len += 1;
14182 }
14183 if !self.added_downstream_actor_id.is_empty() {
14184 len += 1;
14185 }
14186 if !self.removed_downstream_actor_id.is_empty() {
14187 len += 1;
14188 }
14189 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
14190 if self.actor_id != 0 {
14191 struct_ser.serialize_field("actorId", &self.actor_id)?;
14192 }
14193 if self.dispatcher_id != 0 {
14194 #[allow(clippy::needless_borrow)]
14195 #[allow(clippy::needless_borrows_for_generic_args)]
14196 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
14197 }
14198 if let Some(v) = self.hash_mapping.as_ref() {
14199 struct_ser.serialize_field("hashMapping", v)?;
14200 }
14201 if !self.added_downstream_actor_id.is_empty() {
14202 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
14203 }
14204 if !self.removed_downstream_actor_id.is_empty() {
14205 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
14206 }
14207 struct_ser.end()
14208 }
14209}
14210impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
14211 #[allow(deprecated)]
14212 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14213 where
14214 D: serde::Deserializer<'de>,
14215 {
14216 const FIELDS: &[&str] = &[
14217 "actor_id",
14218 "actorId",
14219 "dispatcher_id",
14220 "dispatcherId",
14221 "hash_mapping",
14222 "hashMapping",
14223 "added_downstream_actor_id",
14224 "addedDownstreamActorId",
14225 "removed_downstream_actor_id",
14226 "removedDownstreamActorId",
14227 ];
14228
14229 #[allow(clippy::enum_variant_names)]
14230 enum GeneratedField {
14231 ActorId,
14232 DispatcherId,
14233 HashMapping,
14234 AddedDownstreamActorId,
14235 RemovedDownstreamActorId,
14236 }
14237 impl<'de> serde::Deserialize<'de> for GeneratedField {
14238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14239 where
14240 D: serde::Deserializer<'de>,
14241 {
14242 struct GeneratedVisitor;
14243
14244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14245 type Value = GeneratedField;
14246
14247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14248 write!(formatter, "expected one of: {:?}", &FIELDS)
14249 }
14250
14251 #[allow(unused_variables)]
14252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14253 where
14254 E: serde::de::Error,
14255 {
14256 match value {
14257 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14258 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
14259 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
14260 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
14261 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
14262 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14263 }
14264 }
14265 }
14266 deserializer.deserialize_identifier(GeneratedVisitor)
14267 }
14268 }
14269 struct GeneratedVisitor;
14270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14271 type Value = update_mutation::DispatcherUpdate;
14272
14273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14274 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
14275 }
14276
14277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
14278 where
14279 V: serde::de::MapAccess<'de>,
14280 {
14281 let mut actor_id__ = None;
14282 let mut dispatcher_id__ = None;
14283 let mut hash_mapping__ = None;
14284 let mut added_downstream_actor_id__ = None;
14285 let mut removed_downstream_actor_id__ = None;
14286 while let Some(k) = map_.next_key()? {
14287 match k {
14288 GeneratedField::ActorId => {
14289 if actor_id__.is_some() {
14290 return Err(serde::de::Error::duplicate_field("actorId"));
14291 }
14292 actor_id__ =
14293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14294 ;
14295 }
14296 GeneratedField::DispatcherId => {
14297 if dispatcher_id__.is_some() {
14298 return Err(serde::de::Error::duplicate_field("dispatcherId"));
14299 }
14300 dispatcher_id__ =
14301 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14302 ;
14303 }
14304 GeneratedField::HashMapping => {
14305 if hash_mapping__.is_some() {
14306 return Err(serde::de::Error::duplicate_field("hashMapping"));
14307 }
14308 hash_mapping__ = map_.next_value()?;
14309 }
14310 GeneratedField::AddedDownstreamActorId => {
14311 if added_downstream_actor_id__.is_some() {
14312 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
14313 }
14314 added_downstream_actor_id__ =
14315 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14316 .into_iter().map(|x| x.0).collect())
14317 ;
14318 }
14319 GeneratedField::RemovedDownstreamActorId => {
14320 if removed_downstream_actor_id__.is_some() {
14321 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
14322 }
14323 removed_downstream_actor_id__ =
14324 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14325 .into_iter().map(|x| x.0).collect())
14326 ;
14327 }
14328 }
14329 }
14330 Ok(update_mutation::DispatcherUpdate {
14331 actor_id: actor_id__.unwrap_or_default(),
14332 dispatcher_id: dispatcher_id__.unwrap_or_default(),
14333 hash_mapping: hash_mapping__,
14334 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
14335 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
14336 })
14337 }
14338 }
14339 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
14340 }
14341}
14342impl serde::Serialize for update_mutation::MergeUpdate {
14343 #[allow(deprecated)]
14344 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14345 where
14346 S: serde::Serializer,
14347 {
14348 use serde::ser::SerializeStruct;
14349 let mut len = 0;
14350 if self.actor_id != 0 {
14351 len += 1;
14352 }
14353 if self.upstream_fragment_id != 0 {
14354 len += 1;
14355 }
14356 if self.new_upstream_fragment_id.is_some() {
14357 len += 1;
14358 }
14359 if !self.added_upstream_actors.is_empty() {
14360 len += 1;
14361 }
14362 if !self.removed_upstream_actor_id.is_empty() {
14363 len += 1;
14364 }
14365 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
14366 if self.actor_id != 0 {
14367 struct_ser.serialize_field("actorId", &self.actor_id)?;
14368 }
14369 if self.upstream_fragment_id != 0 {
14370 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
14371 }
14372 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
14373 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
14374 }
14375 if !self.added_upstream_actors.is_empty() {
14376 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
14377 }
14378 if !self.removed_upstream_actor_id.is_empty() {
14379 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
14380 }
14381 struct_ser.end()
14382 }
14383}
14384impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
14385 #[allow(deprecated)]
14386 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14387 where
14388 D: serde::Deserializer<'de>,
14389 {
14390 const FIELDS: &[&str] = &[
14391 "actor_id",
14392 "actorId",
14393 "upstream_fragment_id",
14394 "upstreamFragmentId",
14395 "new_upstream_fragment_id",
14396 "newUpstreamFragmentId",
14397 "added_upstream_actors",
14398 "addedUpstreamActors",
14399 "removed_upstream_actor_id",
14400 "removedUpstreamActorId",
14401 ];
14402
14403 #[allow(clippy::enum_variant_names)]
14404 enum GeneratedField {
14405 ActorId,
14406 UpstreamFragmentId,
14407 NewUpstreamFragmentId,
14408 AddedUpstreamActors,
14409 RemovedUpstreamActorId,
14410 }
14411 impl<'de> serde::Deserialize<'de> for GeneratedField {
14412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14413 where
14414 D: serde::Deserializer<'de>,
14415 {
14416 struct GeneratedVisitor;
14417
14418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14419 type Value = GeneratedField;
14420
14421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14422 write!(formatter, "expected one of: {:?}", &FIELDS)
14423 }
14424
14425 #[allow(unused_variables)]
14426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14427 where
14428 E: serde::de::Error,
14429 {
14430 match value {
14431 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14432 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
14433 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
14434 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
14435 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
14436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14437 }
14438 }
14439 }
14440 deserializer.deserialize_identifier(GeneratedVisitor)
14441 }
14442 }
14443 struct GeneratedVisitor;
14444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14445 type Value = update_mutation::MergeUpdate;
14446
14447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14448 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
14449 }
14450
14451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
14452 where
14453 V: serde::de::MapAccess<'de>,
14454 {
14455 let mut actor_id__ = None;
14456 let mut upstream_fragment_id__ = None;
14457 let mut new_upstream_fragment_id__ = None;
14458 let mut added_upstream_actors__ = None;
14459 let mut removed_upstream_actor_id__ = None;
14460 while let Some(k) = map_.next_key()? {
14461 match k {
14462 GeneratedField::ActorId => {
14463 if actor_id__.is_some() {
14464 return Err(serde::de::Error::duplicate_field("actorId"));
14465 }
14466 actor_id__ =
14467 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14468 ;
14469 }
14470 GeneratedField::UpstreamFragmentId => {
14471 if upstream_fragment_id__.is_some() {
14472 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
14473 }
14474 upstream_fragment_id__ =
14475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14476 ;
14477 }
14478 GeneratedField::NewUpstreamFragmentId => {
14479 if new_upstream_fragment_id__.is_some() {
14480 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
14481 }
14482 new_upstream_fragment_id__ =
14483 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14484 ;
14485 }
14486 GeneratedField::AddedUpstreamActors => {
14487 if added_upstream_actors__.is_some() {
14488 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
14489 }
14490 added_upstream_actors__ = Some(map_.next_value()?);
14491 }
14492 GeneratedField::RemovedUpstreamActorId => {
14493 if removed_upstream_actor_id__.is_some() {
14494 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
14495 }
14496 removed_upstream_actor_id__ =
14497 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14498 .into_iter().map(|x| x.0).collect())
14499 ;
14500 }
14501 }
14502 }
14503 Ok(update_mutation::MergeUpdate {
14504 actor_id: actor_id__.unwrap_or_default(),
14505 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
14506 new_upstream_fragment_id: new_upstream_fragment_id__,
14507 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
14508 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
14509 })
14510 }
14511 }
14512 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
14513 }
14514}
14515impl serde::Serialize for ValuesNode {
14516 #[allow(deprecated)]
14517 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14518 where
14519 S: serde::Serializer,
14520 {
14521 use serde::ser::SerializeStruct;
14522 let mut len = 0;
14523 if !self.tuples.is_empty() {
14524 len += 1;
14525 }
14526 if !self.fields.is_empty() {
14527 len += 1;
14528 }
14529 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
14530 if !self.tuples.is_empty() {
14531 struct_ser.serialize_field("tuples", &self.tuples)?;
14532 }
14533 if !self.fields.is_empty() {
14534 struct_ser.serialize_field("fields", &self.fields)?;
14535 }
14536 struct_ser.end()
14537 }
14538}
14539impl<'de> serde::Deserialize<'de> for ValuesNode {
14540 #[allow(deprecated)]
14541 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14542 where
14543 D: serde::Deserializer<'de>,
14544 {
14545 const FIELDS: &[&str] = &[
14546 "tuples",
14547 "fields",
14548 ];
14549
14550 #[allow(clippy::enum_variant_names)]
14551 enum GeneratedField {
14552 Tuples,
14553 Fields,
14554 }
14555 impl<'de> serde::Deserialize<'de> for GeneratedField {
14556 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14557 where
14558 D: serde::Deserializer<'de>,
14559 {
14560 struct GeneratedVisitor;
14561
14562 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14563 type Value = GeneratedField;
14564
14565 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14566 write!(formatter, "expected one of: {:?}", &FIELDS)
14567 }
14568
14569 #[allow(unused_variables)]
14570 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14571 where
14572 E: serde::de::Error,
14573 {
14574 match value {
14575 "tuples" => Ok(GeneratedField::Tuples),
14576 "fields" => Ok(GeneratedField::Fields),
14577 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14578 }
14579 }
14580 }
14581 deserializer.deserialize_identifier(GeneratedVisitor)
14582 }
14583 }
14584 struct GeneratedVisitor;
14585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14586 type Value = ValuesNode;
14587
14588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14589 formatter.write_str("struct stream_plan.ValuesNode")
14590 }
14591
14592 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
14593 where
14594 V: serde::de::MapAccess<'de>,
14595 {
14596 let mut tuples__ = None;
14597 let mut fields__ = None;
14598 while let Some(k) = map_.next_key()? {
14599 match k {
14600 GeneratedField::Tuples => {
14601 if tuples__.is_some() {
14602 return Err(serde::de::Error::duplicate_field("tuples"));
14603 }
14604 tuples__ = Some(map_.next_value()?);
14605 }
14606 GeneratedField::Fields => {
14607 if fields__.is_some() {
14608 return Err(serde::de::Error::duplicate_field("fields"));
14609 }
14610 fields__ = Some(map_.next_value()?);
14611 }
14612 }
14613 }
14614 Ok(ValuesNode {
14615 tuples: tuples__.unwrap_or_default(),
14616 fields: fields__.unwrap_or_default(),
14617 })
14618 }
14619 }
14620 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
14621 }
14622}
14623impl serde::Serialize for values_node::ExprTuple {
14624 #[allow(deprecated)]
14625 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14626 where
14627 S: serde::Serializer,
14628 {
14629 use serde::ser::SerializeStruct;
14630 let mut len = 0;
14631 if !self.cells.is_empty() {
14632 len += 1;
14633 }
14634 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
14635 if !self.cells.is_empty() {
14636 struct_ser.serialize_field("cells", &self.cells)?;
14637 }
14638 struct_ser.end()
14639 }
14640}
14641impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
14642 #[allow(deprecated)]
14643 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14644 where
14645 D: serde::Deserializer<'de>,
14646 {
14647 const FIELDS: &[&str] = &[
14648 "cells",
14649 ];
14650
14651 #[allow(clippy::enum_variant_names)]
14652 enum GeneratedField {
14653 Cells,
14654 }
14655 impl<'de> serde::Deserialize<'de> for GeneratedField {
14656 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14657 where
14658 D: serde::Deserializer<'de>,
14659 {
14660 struct GeneratedVisitor;
14661
14662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14663 type Value = GeneratedField;
14664
14665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14666 write!(formatter, "expected one of: {:?}", &FIELDS)
14667 }
14668
14669 #[allow(unused_variables)]
14670 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14671 where
14672 E: serde::de::Error,
14673 {
14674 match value {
14675 "cells" => Ok(GeneratedField::Cells),
14676 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14677 }
14678 }
14679 }
14680 deserializer.deserialize_identifier(GeneratedVisitor)
14681 }
14682 }
14683 struct GeneratedVisitor;
14684 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14685 type Value = values_node::ExprTuple;
14686
14687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14688 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
14689 }
14690
14691 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
14692 where
14693 V: serde::de::MapAccess<'de>,
14694 {
14695 let mut cells__ = None;
14696 while let Some(k) = map_.next_key()? {
14697 match k {
14698 GeneratedField::Cells => {
14699 if cells__.is_some() {
14700 return Err(serde::de::Error::duplicate_field("cells"));
14701 }
14702 cells__ = Some(map_.next_value()?);
14703 }
14704 }
14705 }
14706 Ok(values_node::ExprTuple {
14707 cells: cells__.unwrap_or_default(),
14708 })
14709 }
14710 }
14711 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
14712 }
14713}
14714impl serde::Serialize for Watermark {
14715 #[allow(deprecated)]
14716 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14717 where
14718 S: serde::Serializer,
14719 {
14720 use serde::ser::SerializeStruct;
14721 let mut len = 0;
14722 if self.column.is_some() {
14723 len += 1;
14724 }
14725 if self.val.is_some() {
14726 len += 1;
14727 }
14728 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
14729 if let Some(v) = self.column.as_ref() {
14730 struct_ser.serialize_field("column", v)?;
14731 }
14732 if let Some(v) = self.val.as_ref() {
14733 struct_ser.serialize_field("val", v)?;
14734 }
14735 struct_ser.end()
14736 }
14737}
14738impl<'de> serde::Deserialize<'de> for Watermark {
14739 #[allow(deprecated)]
14740 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14741 where
14742 D: serde::Deserializer<'de>,
14743 {
14744 const FIELDS: &[&str] = &[
14745 "column",
14746 "val",
14747 ];
14748
14749 #[allow(clippy::enum_variant_names)]
14750 enum GeneratedField {
14751 Column,
14752 Val,
14753 }
14754 impl<'de> serde::Deserialize<'de> for GeneratedField {
14755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14756 where
14757 D: serde::Deserializer<'de>,
14758 {
14759 struct GeneratedVisitor;
14760
14761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14762 type Value = GeneratedField;
14763
14764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14765 write!(formatter, "expected one of: {:?}", &FIELDS)
14766 }
14767
14768 #[allow(unused_variables)]
14769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14770 where
14771 E: serde::de::Error,
14772 {
14773 match value {
14774 "column" => Ok(GeneratedField::Column),
14775 "val" => Ok(GeneratedField::Val),
14776 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14777 }
14778 }
14779 }
14780 deserializer.deserialize_identifier(GeneratedVisitor)
14781 }
14782 }
14783 struct GeneratedVisitor;
14784 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14785 type Value = Watermark;
14786
14787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14788 formatter.write_str("struct stream_plan.Watermark")
14789 }
14790
14791 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
14792 where
14793 V: serde::de::MapAccess<'de>,
14794 {
14795 let mut column__ = None;
14796 let mut val__ = None;
14797 while let Some(k) = map_.next_key()? {
14798 match k {
14799 GeneratedField::Column => {
14800 if column__.is_some() {
14801 return Err(serde::de::Error::duplicate_field("column"));
14802 }
14803 column__ = map_.next_value()?;
14804 }
14805 GeneratedField::Val => {
14806 if val__.is_some() {
14807 return Err(serde::de::Error::duplicate_field("val"));
14808 }
14809 val__ = map_.next_value()?;
14810 }
14811 }
14812 }
14813 Ok(Watermark {
14814 column: column__,
14815 val: val__,
14816 })
14817 }
14818 }
14819 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
14820 }
14821}
14822impl serde::Serialize for WatermarkFilterNode {
14823 #[allow(deprecated)]
14824 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14825 where
14826 S: serde::Serializer,
14827 {
14828 use serde::ser::SerializeStruct;
14829 let mut len = 0;
14830 if !self.watermark_descs.is_empty() {
14831 len += 1;
14832 }
14833 if !self.tables.is_empty() {
14834 len += 1;
14835 }
14836 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
14837 if !self.watermark_descs.is_empty() {
14838 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
14839 }
14840 if !self.tables.is_empty() {
14841 struct_ser.serialize_field("tables", &self.tables)?;
14842 }
14843 struct_ser.end()
14844 }
14845}
14846impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
14847 #[allow(deprecated)]
14848 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14849 where
14850 D: serde::Deserializer<'de>,
14851 {
14852 const FIELDS: &[&str] = &[
14853 "watermark_descs",
14854 "watermarkDescs",
14855 "tables",
14856 ];
14857
14858 #[allow(clippy::enum_variant_names)]
14859 enum GeneratedField {
14860 WatermarkDescs,
14861 Tables,
14862 }
14863 impl<'de> serde::Deserialize<'de> for GeneratedField {
14864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14865 where
14866 D: serde::Deserializer<'de>,
14867 {
14868 struct GeneratedVisitor;
14869
14870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14871 type Value = GeneratedField;
14872
14873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14874 write!(formatter, "expected one of: {:?}", &FIELDS)
14875 }
14876
14877 #[allow(unused_variables)]
14878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14879 where
14880 E: serde::de::Error,
14881 {
14882 match value {
14883 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
14884 "tables" => Ok(GeneratedField::Tables),
14885 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14886 }
14887 }
14888 }
14889 deserializer.deserialize_identifier(GeneratedVisitor)
14890 }
14891 }
14892 struct GeneratedVisitor;
14893 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14894 type Value = WatermarkFilterNode;
14895
14896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14897 formatter.write_str("struct stream_plan.WatermarkFilterNode")
14898 }
14899
14900 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
14901 where
14902 V: serde::de::MapAccess<'de>,
14903 {
14904 let mut watermark_descs__ = None;
14905 let mut tables__ = None;
14906 while let Some(k) = map_.next_key()? {
14907 match k {
14908 GeneratedField::WatermarkDescs => {
14909 if watermark_descs__.is_some() {
14910 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
14911 }
14912 watermark_descs__ = Some(map_.next_value()?);
14913 }
14914 GeneratedField::Tables => {
14915 if tables__.is_some() {
14916 return Err(serde::de::Error::duplicate_field("tables"));
14917 }
14918 tables__ = Some(map_.next_value()?);
14919 }
14920 }
14921 }
14922 Ok(WatermarkFilterNode {
14923 watermark_descs: watermark_descs__.unwrap_or_default(),
14924 tables: tables__.unwrap_or_default(),
14925 })
14926 }
14927 }
14928 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
14929 }
14930}